From da50130307fd6caa1a95875f36600cc75502b285 Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Tue, 15 Jul 2025 15:29:11 +0700
Subject: [PATCH 1/8] feat: add stub implementations of array types

---
 pyproject.toml                                |   10 +-
 src/_algopy_testing/arc4.py                   |  118 +-
 src/_algopy_testing/decorators/arc4.py        |   15 +-
 src/_algopy_testing/primitives/__init__.py    |   24 +-
 src/_algopy_testing/primitives/array.py       |  474 +++-
 src/_algopy_testing/serialize.py              |   68 +-
 src/_algopy_testing/utils.py                  |   19 +
 src/algopy/__init__.py                        |   21 +-
 tests/arc4/test_address.py                    |    7 +
 tests/arc4/test_dynamic_array.py              |   55 +
 tests/arc4/test_static_array.py               |   65 +
 .../data/SignaturesContract.approval.teal     |   21 +-
 .../data/SignaturesContract.arc32.json        |    2 +-
 .../data/SignaturesContract.arc56.json        |   15 +-
 .../data/Arc4InnerTxnsContract.arc56.json     |    4 +-
 .../Arc4PrimitiveOpsContract.approval.teal    |   28 +-
 .../data/Arc4PrimitiveOpsContract.arc32.json  |    2 +-
 .../data/Arc4PrimitiveOpsContract.arc56.json  |  296 +--
 .../Arrays/data/Contract.approval.teal        | 1028 +++++----
 .../artifacts/Arrays/data/Contract.arc32.json |   28 +-
 .../artifacts/Arrays/data/Contract.arc56.json |  159 +-
 .../data/ImmutableArrayContract.approval.teal | 1984 ++++++++++-------
 .../data/ImmutableArrayContract.arc32.json    |   52 +-
 .../data/ImmutableArrayContract.arc56.json    |  294 ++-
 .../data/StaticSizeContract.approval.teal     |  886 +++++---
 .../Arrays/data/StaticSizeContract.arc32.json |   15 +-
 .../Arrays/data/StaticSizeContract.arc56.json |  143 +-
 tests/artifacts/Arrays/immutable.py           |   98 +-
 tests/artifacts/Arrays/static_size.py         |   61 +-
 tests/artifacts/Arrays/uint64.py              |   80 +-
 .../data/BoxContract.approval.teal            |   22 +-
 .../BoxContract/data/BoxContract.arc32.json   |    2 +-
 .../BoxContract/data/BoxContract.arc56.json   |   14 +-
 .../CreatedAppAsset/data/AppCall.arc56.json   |    4 +-
 .../data/AppExpectingEffects.arc56.json       |    4 +-
 .../data/CryptoOpsContract.approval.teal      |   52 +-
 .../data/CryptoOpsContract.arc32.json         |    2 +-
 .../data/CryptoOpsContract.arc56.json         |    8 +-
 .../data/GlobalStateValidator.arc56.json      |    4 +-
 .../MiscellaneousOpsContract.approval.teal    |    8 +-
 .../data/MiscellaneousOpsContract.arc32.json  |    2 +-
 .../data/MiscellaneousOpsContract.arc56.json  |   46 +-
 .../data/PrimitiveOpsContract.arc56.json      |    4 +-
 .../data/StateMutations.approval.teal         |  126 +-
 .../data/StateMutations.arc32.json            |    2 +-
 .../data/StateMutations.arc56.json            |   68 +-
 .../data/GlobalStateContract.approval.teal    |   42 +-
 .../data/GlobalStateContract.arc32.json       |    2 +-
 .../data/GlobalStateContract.arc56.json       |  128 +-
 .../StateOps/data/ITxnOpsContract.arc56.json  |    4 +-
 .../data/LocalStateContract.approval.teal     |   27 +-
 .../data/LocalStateContract.arc32.json        |    2 +-
 .../data/LocalStateContract.arc56.json        |   72 +-
 .../StateAcctParamsGetContract.approval.teal  |   20 +-
 .../StateAcctParamsGetContract.arc32.json     |    2 +-
 .../StateAcctParamsGetContract.arc56.json     |    6 +-
 .../data/StateAppGlobalContract.arc56.json    |    4 +-
 .../StateAppGlobalExContract.approval.teal    |    4 +
 .../data/StateAppGlobalExContract.arc32.json  |    2 +-
 .../data/StateAppGlobalExContract.arc56.json  |    6 +-
 .../data/StateAppLocalContract.arc56.json     |    4 +-
 .../data/StateAppLocalExContract.arc56.json   |    4 +-
 .../data/StateAppParamsContract.arc56.json    |    4 +-
 .../data/StateAssetHoldingContract.arc56.json |    4 +-
 .../data/StateAssetParamsContract.arc56.json  |    4 +-
 .../Tuples/data/TuplesContract.arc56.json     |    4 +-
 tests/models/test_box.py                      |   90 +
 tests/test_array.py                           |   47 +-
 tests/utilities/test_size_of.py               |   38 +-
 69 files changed, 4625 insertions(+), 2335 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 6149b5dc..13ee93da 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,7 @@ dependencies = [
     "pynacl>=1.4.0,<2",
     "ecdsa>=0.17.0",
     "coincurve>=19.0.1",
-    "algorand-python>=2.0"
+    "algorand-python @ file://{root}/../puya/stubs",
 ]
 
 [project.urls]
@@ -50,7 +50,7 @@ type = "virtual"
 path = ".venv"
 python = "3.12"
 dependencies = [
-    "puyapy>=3.0",
+    "puyapy @ {root:parent:uri}/puya",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -81,7 +81,7 @@ check = [
 ]
 # type checks algorand-python-testing code
 mypy_testing = "mypy . --exclude examples"
-tests = "pytest --cov=src --cov-report xml"
+tests = "pytest --cov=src --cov-report xml {args}"
 tests_cov = [
     "pytest --cov=src --cov-report=html",
     "python -m webbrowser -t 'file://{root:uri}/htmlcov/index.html'"
@@ -132,7 +132,7 @@ dependencies = [
     "pytest-cov>=4.1.0",
     "py-algorand-sdk>=2.4.0",
     "algokit-utils>=3.0.0",
-    "puyapy>=3.0",
+    "puyapy @ {root:parent:uri}/puya",
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -183,7 +183,7 @@ post-install-commands = [
   "hatch run examples:reload_algopy_testing",
 ]
 dependencies = [
-    "algorand-python>=1.2",
+    "algorand-python @ file://{root}/../puya/stubs",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
diff --git a/src/_algopy_testing/arc4.py b/src/_algopy_testing/arc4.py
index 83153827..26de796b 100644
--- a/src/_algopy_testing/arc4.py
+++ b/src/_algopy_testing/arc4.py
@@ -25,6 +25,7 @@
 )
 from _algopy_testing.primitives import Bytes
 from _algopy_testing.protocols import BytesBacked
+from _algopy_testing.serialize import get_native_to_arc4_serializer
 from _algopy_testing.utils import (
     as_bytes,
     as_int,
@@ -32,7 +33,10 @@
     as_int64,
     as_int512,
     as_string,
+    get_int_literal_from_type_generic,
+    get_type_generic_from_int_literal,
     int_to_bytes,
+    parameterize_type,
     raise_mocked_function_error,
 )
 
@@ -101,28 +105,9 @@ def __repr__(self) -> str:
         return self.arc4_name
 
 
-def _get_int_literal(literal_type: type) -> int:
-    type_args = typing.get_args(literal_type)
-    try:
-        (int_arg,) = type_args
-    except ValueError:
-        int_arg = 0
-    return int(int_arg)
-
-
-def _create_int_literal(value: int) -> type:
-    return typing.cast(type, typing.Literal[value])
-
-
-def _parameterize_type(type_: type, *params: type) -> type:
-    if len(params) == 1:
-        return typing.cast(type, type_[params[0]])  # type: ignore[index]
-    return typing.cast(type, type_[params])  # type: ignore[index]
-
-
 def _get_type_param_name(typ: type) -> str:
     if typ.__name__ == "Literal":
-        int_arg = _get_int_literal(typ)
+        int_arg = get_int_literal_from_type_generic(typ)
         return str(int_arg)
     return typ.__name__
 
@@ -282,7 +267,7 @@ def __init__(self, size: int) -> None:
 
     @property
     def typ(self) -> type:
-        return _parameterize_type(self._type, _create_int_literal(self.bit_size))
+        return parameterize_type(self._type, get_type_generic_from_int_literal(self.bit_size))
 
     @property
     def arc4_name(self) -> str:
@@ -297,7 +282,7 @@ def __getitem__(cls, key_t: type[_TBitSize]) -> type:
         cache = cls.__concrete__
         if c := cache.get(key_t, None):
             return c
-        size = _get_int_literal(key_t)
+        size = get_int_literal_from_type_generic(key_t)
         cache[key_t] = c = _new_parameterized_class(cls, [key_t], _UIntTypeInfo(size))
         return c
 
@@ -407,8 +392,10 @@ def __init__(self, size: int, precision: int) -> None:
 
     @property
     def typ(self) -> type:
-        return _parameterize_type(
-            _UFixedNxM, _create_int_literal(self.bit_size), _create_int_literal(self.precision)
+        return parameterize_type(
+            _UFixedNxM,
+            get_type_generic_from_int_literal(self.bit_size),
+            get_type_generic_from_int_literal(self.precision),
         )
 
     @property
@@ -425,8 +412,8 @@ def __getitem__(cls, key_t: tuple[type[_TBitSize], type[_TDecimalPlaces]]) -> ty
             return c
 
         size_t, precision_t = key_t
-        size = _get_int_literal(size_t)
-        precision = _get_int_literal(precision_t)
+        size = get_int_literal_from_type_generic(size_t)
+        precision = get_int_literal_from_type_generic(precision_t)
         cache[key_t] = c = _new_parameterized_class(
             cls,
             key_t,
@@ -545,6 +532,13 @@ class Bool(_ABIEncoded):
     def __init__(self, value: bool = False, /) -> None:  # noqa: FBT001, FBT002
         self._value = int_to_bytes(self._true_int_value if value else self._false_int_value, 1)
 
+    def __eq__(self, other: object) -> bool:
+        try:
+            other_bool = bool(other)
+        except (TypeError, ValueError):
+            return NotImplemented
+        return self.native == other_bool
+
     def __bool__(self) -> bool:
         """Allow Bool to be used in boolean contexts."""
         return self.native
@@ -563,6 +557,7 @@ def __repr__(self) -> str:
 
 
 _TArrayItem = typing.TypeVar("_TArrayItem", bound=_ABIEncoded)
+_TNativeArrayItem = typing.TypeVar("_TNativeArrayItem")
 _TArrayLength = typing.TypeVar("_TArrayLength", bound=int)
 
 
@@ -573,7 +568,9 @@ def __init__(self, item_type: _TypeInfo, size: int):
 
     @property
     def typ(self) -> type:
-        return _parameterize_type(StaticArray, self.item_type.typ, _create_int_literal(self.size))
+        return parameterize_type(
+            StaticArray, self.item_type.typ, get_type_generic_from_int_literal(self.size)
+        )
 
     @property
     def arc4_name(self) -> str:
@@ -594,7 +591,7 @@ def __getitem__(cls, key_t: tuple[type[_TArrayItem], type[_TArrayLength]]) -> ty
 
         item_t, size_t = key_t
         assert issubclass(item_t, _ABIEncoded)
-        size = _get_int_literal(size_t)
+        size = get_int_literal_from_type_generic(size_t)
         cache[key_t] = c = _new_parameterized_class(
             cls,
             key_t,
@@ -625,20 +622,23 @@ def __new__(cls, *items: _TArrayItem) -> typing.Self:
             except IndexError:
                 raise TypeError("array must have an item type") from None
             size = len(items)
-            cls = _parameterize_type(cls, type(item), _create_int_literal(size))
+            cls = parameterize_type(cls, type(item), get_type_generic_from_int_literal(size))
         instance = super().__new__(cls)
         return instance
 
     def __init__(self, *_items: _TArrayItem):
         super().__init__()
         items = _check_is_arc4(_items)
+
+        if len(items) != 0 and len(items) != self._type_info.size:
+            raise TypeError(f"expected {self._type_info.size} items, not {len(items)}")
+
         for item in items:
-            if len(items) != self._type_info.size:
-                raise TypeError(f"expected {self._type_info.size} items, not {len(items)}")
             if self._type_info.item_type != item._type_info:
                 raise TypeError(
                     f"item must be of type {self._type_info.item_type!r}, not {item._type_info!r}"
                 )
+
         self._value = _encode(items)
 
     def __iter__(self) -> Iterator[_TArrayItem]:
@@ -651,7 +651,7 @@ def __reversed__(self) -> Iterator[_TArrayItem]:
 
     @property
     def length(self) -> algopy.UInt64:
-        # """Returns the current length of the array"""
+        # """Returns the length of the array"""
         import algopy
 
         return algopy.UInt64(self._type_info.size)
@@ -681,6 +681,26 @@ def __repr__(self) -> str:
         items = map(repr, self._list())
         return f"{_arc4_type_repr(type(self))}({', '.join(items)})"
 
+    def to_native(
+        self, element_type: type[_TNativeArrayItem], /
+    ) -> algopy.FixedArray[_TNativeArrayItem, _TArrayLength]:
+        """Convert to an `algopy.FixedArray` with the specified element type.
+
+        Only allowed if the element type is compatible with this arrays element type
+        e.g. arc4.UInt64 -> UInt64
+        """
+        import algopy
+
+        serializer = get_native_to_arc4_serializer(element_type)
+        type_info = serializer.arc4_type._type_info
+        if type_info != self._type_info.item_type:
+            raise TypeError(
+                f"cannot convert {self._type_info.item_type!r} to {type_info!r} "
+                f"for element type {element_type!r}"
+            )
+        items = [serializer.arc4_to_native(item) for item in self._list()]
+        return algopy.FixedArray(items)
+
 
 class _AddressTypeInfo(_StaticArrayTypeInfo):
     def __init__(self) -> None:
@@ -749,7 +769,7 @@ def __init__(self, item_type: _TypeInfo) -> None:
 
     @property
     def typ(self) -> type:
-        return _parameterize_type(DynamicArray, self.item_type.typ)
+        return parameterize_type(DynamicArray, self.item_type.typ)
 
     @property
     def arc4_name(self) -> str:
@@ -792,7 +812,7 @@ def __new__(cls, *items: _TArrayItem) -> typing.Self:
                 item = items[0]
             except IndexError:
                 raise TypeError("array must have an item type") from None
-            cls = _parameterize_type(cls, type(item))
+            cls = parameterize_type(cls, type(item))
         instance = super().__new__(cls)
         return instance
 
@@ -889,6 +909,26 @@ def __repr__(self) -> str:
         items = map(repr, self._list())
         return f"{_arc4_type_repr(type(self))}({', '.join(items)})"
 
+    def to_native(
+        self, element_type: type[_TNativeArrayItem], /
+    ) -> algopy.Array[_TNativeArrayItem]:
+        """Convert to an `algopy.Array` with the specified element type.
+
+        Only allowed if the element type is compatible with this arrays element type
+        e.g. arc4.UInt64 -> UInt64
+        """
+        import algopy
+
+        serializer = get_native_to_arc4_serializer(element_type)
+        type_info = serializer.arc4_type._type_info
+        if type_info != self._type_info.item_type:
+            raise TypeError(
+                f"cannot convert {self._type_info.item_type!r} to {type_info!r} "
+                f"for element type {element_type!r}"
+            )
+        items = [serializer.arc4_to_native(item) for item in self._list()]
+        return algopy.Array(items)
+
 
 class _DynamicBytesTypeInfo(_DynamicArrayTypeInfo):
     def __init__(self) -> None:
@@ -946,7 +986,7 @@ def __init__(self, child_types: list[_TypeInfo]) -> None:
 
     @property
     def typ(self) -> type:
-        return _parameterize_type(Tuple, *(t.typ for t in self.child_types))
+        return parameterize_type(Tuple, *(t.typ for t in self.child_types))
 
     @property
     def arc4_name(self) -> str:
@@ -993,7 +1033,7 @@ def __new__(
         except AttributeError:
             if not items:
                 raise TypeError("empty tuple not supported") from None
-            cls = _parameterize_type(cls, *map(type, items))
+            cls = parameterize_type(cls, *map(type, items))
         instance = super().__new__(cls)
         return instance
 
@@ -1035,7 +1075,7 @@ def __iter__(self) -> typing.Iterator[_ABIEncoded]:
     @property
     def native(self) -> tuple[typing.Unpack[_TTuple]]:
         return typing.cast(
-            tuple[typing.Unpack[_TTuple]],
+            "tuple[typing.Unpack[_TTuple]]",
             tuple(_decode_tuple_items(self._value, self._type_info.child_types)),
         )
 
@@ -1080,7 +1120,7 @@ class _StructMeta(type):
 
 def _tuple_type_from_struct(struct: type[Struct]) -> type[Tuple]:  # type: ignore[type-arg]
     field_types = [f.type for f in struct._type_info.fields]
-    return _parameterize_type(Tuple, *field_types)
+    return parameterize_type(Tuple, *field_types)
 
 
 class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):  # type: ignore[misc]
@@ -1123,7 +1163,7 @@ def from_bytes(cls, value: algopy.Bytes | bytes, /) -> typing.Self:
         tuple_type = _tuple_type_from_struct(cls)
         tuple_value = tuple_type.from_bytes(value)
         if not tuple_value:
-            return typing.cast(typing.Self, tuple_value)
+            return typing.cast("typing.Self", tuple_value)
         return cls(*tuple_value.native)
 
     @property
diff --git a/src/_algopy_testing/decorators/arc4.py b/src/_algopy_testing/decorators/arc4.py
index 238cd235..20792faa 100644
--- a/src/_algopy_testing/decorators/arc4.py
+++ b/src/_algopy_testing/decorators/arc4.py
@@ -192,7 +192,6 @@ def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
             check_routing_conditions(app_id, metadata)
             result = fn(*args, **kwargs)
             if result is not None:
-
                 abi_result = native_to_arc4(result)
                 log(ARC4_RETURN_PREFIX, abi_result)
             return result
@@ -329,7 +328,13 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
     from _algopy_testing.arc4 import _ABIEncoded
     from _algopy_testing.gtxn import Transaction, TransactionBase
     from _algopy_testing.models import Account, Application, Asset
-    from _algopy_testing.primitives import ImmutableArray
+    from _algopy_testing.primitives import (
+        Array,
+        FixedArray,
+        ImmutableArray,
+        ImmutableFixedArray,
+        Struct,
+    )
 
     if annotation is None:
         return "void"
@@ -341,12 +346,14 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
     if not isinstance(annotation, type):
         raise TypeError(f"expected type: {annotation!r}")
 
-    if typing.NamedTuple in getattr(annotation, "__orig_bases__", []):
+    if typing.NamedTuple in getattr(annotation, "__orig_bases__", []) or issubclass(
+        annotation, Struct
+    ):
         tuple_fields = list(inspect.get_annotations(annotation).values())
         tuple_args = [_type_to_arc4(a) for a in tuple_fields]
         return f"({','.join(tuple_args)})"
 
-    if issubclass(annotation, ImmutableArray):
+    if issubclass(annotation, Array | FixedArray | ImmutableArray | ImmutableFixedArray):
         return f"{_type_to_arc4(annotation._element_type)}[]"
     # arc4 types
     if issubclass(annotation, _ABIEncoded):
diff --git a/src/_algopy_testing/primitives/__init__.py b/src/_algopy_testing/primitives/__init__.py
index 274b7af3..668f9487 100644
--- a/src/_algopy_testing/primitives/__init__.py
+++ b/src/_algopy_testing/primitives/__init__.py
@@ -1,7 +1,27 @@
-from _algopy_testing.primitives.array import Array, ImmutableArray
+from _algopy_testing.primitives.array import (
+    Array,
+    FixedArray,
+    ImmutableArray,
+    ImmutableFixedArray,
+    ReferenceArray,
+    Struct,
+    zero_bytes,
+)
 from _algopy_testing.primitives.biguint import BigUInt
 from _algopy_testing.primitives.bytes import Bytes
 from _algopy_testing.primitives.string import String
 from _algopy_testing.primitives.uint64 import UInt64
 
-__all__ = ["Array", "BigUInt", "Bytes", "ImmutableArray", "String", "UInt64"]
+__all__ = [
+    "Array",
+    "BigUInt",
+    "Bytes",
+    "FixedArray",
+    "ImmutableArray",
+    "ImmutableFixedArray",
+    "ReferenceArray",
+    "String",
+    "Struct",
+    "UInt64",
+    "zero_bytes",
+]
diff --git a/src/_algopy_testing/primitives/array.py b/src/_algopy_testing/primitives/array.py
index c08a122d..40b31fc8 100644
--- a/src/_algopy_testing/primitives/array.py
+++ b/src/_algopy_testing/primitives/array.py
@@ -1,14 +1,262 @@
+import dataclasses
 import types
 import typing
 from collections.abc import Iterable, Iterator, Reversible
 
+from _algopy_testing.mutable import MutableBytes, add_mutable_callback, set_item_on_mutate
 from _algopy_testing.primitives.uint64 import UInt64
 from _algopy_testing.protocols import Serializable
 from _algopy_testing.serialize import deserialize_from_bytes, serialize_to_bytes
-
+from _algopy_testing.utils import (
+    get_int_literal_from_type_generic,
+    get_static_size_of,
+    get_type_generic_from_int_literal,
+    parameterize_type,
+)
+
+_TArrayItem = typing.TypeVar("_TArrayItem")
+_TArrayLength = typing.TypeVar("_TArrayLength", bound=int)
 _T = typing.TypeVar("_T")
 
 
+class _ImmutableFixedArrayMeta(type, typing.Generic[_TArrayItem, _TArrayLength]):
+    __concrete__: typing.ClassVar[dict[tuple[type, type], type]] = {}
+
+    # get or create a type that is parametrized with element_t and length
+    def __getitem__(cls, item: tuple[type[_TArrayItem], type[_TArrayLength]]) -> type:
+        cache = cls.__concrete__
+        if c := cache.get(item, None):
+            return c
+
+        element_t, length_t = item
+        length = get_int_literal_from_type_generic(length_t)
+        cls_name = f"{cls.__name__}[{element_t.__name__},{length}]"
+        cache[item] = c = types.new_class(
+            cls_name,
+            bases=(cls,),
+            exec_body=lambda ns: ns.update(
+                _element_type=element_t,
+                _length=length,
+            ),
+        )
+
+        return c
+
+
+class ImmutableFixedArray(
+    Serializable,
+    MutableBytes,
+    typing.Generic[_TArrayItem, _TArrayLength],
+    metaclass=_ImmutableFixedArrayMeta,
+):
+    """An immutable fixed length Array of the specified type and length."""
+
+    _element_type: typing.ClassVar[type]
+    _length: int
+
+    def __new__(cls, values: Iterable[_TArrayItem]) -> typing.Self:
+        try:
+            assert cls._element_type
+        except AttributeError:
+            try:
+                items = list(values)
+                item = items[0]
+            except IndexError:
+                raise TypeError("array must have an item type") from None
+            size = len(items)
+            cls = parameterize_type(cls, type(item), get_type_generic_from_int_literal(size))
+        instance = super().__new__(cls)
+        return instance
+
+    def __init__(self, values: Iterable[_TArrayItem]) -> None:
+        super().__init__()
+        items = list(values)
+        if len(items) != 0 and len(items) != self._length:
+            raise TypeError(f"expected {self._length} items, not {len(items)}")
+        for item in items:
+            if not isinstance(item, self._element_type):
+                raise TypeError(f"item must be of type {self._element_type!r}, not {type(item)!r}")
+        self._items = list(items)
+        self._value = serialize_to_bytes(self)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, self.__class__):
+            return (
+                self._element_type == other._element_type
+                and self._length == other._length
+                and self.serialize() == other.serialize()
+            )
+        else:
+            return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.serialize())
+
+    @classmethod
+    def full(cls, item: _TArrayItem) -> typing.Self:
+        return cls(item for _ in range(cls._length))
+
+    def __iter__(self) -> typing.Iterator[_TArrayItem]:
+        return iter(self._items)
+
+    def __reversed__(self) -> typing.Iterator[_TArrayItem]:
+        return reversed(self._items)
+
+    @property
+    def length(self) -> UInt64:
+        return UInt64(len(self._items))
+
+    def __len__(self) -> UInt64:
+        return self.length
+
+    def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
+        value = self._items[index]
+        return set_item_on_mutate(self, index, value)
+
+    def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
+        self._items[int(index)] = value
+        self._value = serialize_to_bytes(self)
+        return value
+
+    def replace(
+        self, index: UInt64 | int, value: _TArrayItem
+    ) -> "ImmutableFixedArray[_TArrayItem, _TArrayLength]":
+        copied = list(self._items)
+        copied[int(index)] = value
+        return self._from_iter(copied)
+
+    def copy(self) -> typing.Self:
+        return self.__class__.from_bytes(self.serialize())
+
+    def _from_iter(
+        self, items: Iterable[_TArrayItem]
+    ) -> "ImmutableFixedArray[_TArrayItem, _TArrayLength]":
+        el_type = self._element_type
+        l_type = get_type_generic_from_int_literal(self._length)
+        typ = ImmutableFixedArray[el_type, l_type]  # type: ignore[valid-type]
+        return typ(items)
+
+    def serialize(self) -> bytes:
+        return serialize_to_bytes(self)
+
+    @classmethod
+    def from_bytes(cls, value: bytes, /) -> typing.Self:
+        return deserialize_from_bytes(cls, value)
+
+
+class _FixedArrayMeta(type, typing.Generic[_TArrayItem, _TArrayLength]):
+    __concrete__: typing.ClassVar[dict[tuple[type, type], type]] = {}
+
+    # get or create a type that is parametrized with element_t and length
+    def __getitem__(cls, item: tuple[type[_TArrayItem], type[_TArrayLength]]) -> type:
+        cache = cls.__concrete__
+        if c := cache.get(item, None):
+            return c
+
+        element_t, length_t = item
+        length = get_int_literal_from_type_generic(length_t)
+        cls_name = f"{cls.__name__}[{element_t.__name__},{length}]"
+        cache[item] = c = types.new_class(
+            cls_name,
+            bases=(cls,),
+            exec_body=lambda ns: ns.update(
+                _element_type=element_t,
+                _length=length,
+            ),
+        )
+
+        return c
+
+
+class FixedArray(
+    Serializable,
+    MutableBytes,
+    typing.Generic[_TArrayItem, _TArrayLength],
+    metaclass=_FixedArrayMeta,
+):
+    """A fixed length Array of the specified type and length."""
+
+    _element_type: typing.ClassVar[type]
+    _length: int
+
+    def __new__(cls, values: Iterable[_TArrayItem]) -> typing.Self:
+        try:
+            assert cls._element_type
+        except AttributeError:
+            try:
+                items = list(values)
+                item = items[0]
+            except IndexError:
+                raise TypeError("array must have an item type") from None
+            size = len(items)
+            cls = parameterize_type(cls, type(item), get_type_generic_from_int_literal(size))
+        instance = super().__new__(cls)
+        return instance
+
+    def __init__(self, values: Iterable[_TArrayItem]) -> None:
+        super().__init__()
+        items = list(values)
+        if len(items) != 0 and len(items) != self._length:
+            raise TypeError(f"expected {self._length} items, not {len(items)}")
+        for item in items:
+            if not isinstance(item, self._element_type):
+                raise TypeError(f"item must be of type {self._element_type!r}, not {type(item)!r}")
+        self._items = list(items)
+        self._value = serialize_to_bytes(self)
+
+    @classmethod
+    def full(cls, item: _TArrayItem) -> typing.Self:
+        return cls(item for _ in range(cls._length))
+
+    def __iter__(self) -> typing.Iterator[_TArrayItem]:
+        return iter(self._items)
+
+    def __reversed__(self) -> typing.Iterator[_TArrayItem]:
+        return reversed(self._items)
+
+    @property
+    def length(self) -> UInt64:
+        return UInt64(len(self._items))
+
+    def __len__(self) -> UInt64:
+        return self.length
+
+    def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
+        value = self._items[index]
+        return set_item_on_mutate(self, index, value)
+
+    def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
+        self._items[int(index)] = value
+        self._value = serialize_to_bytes(self)
+        return value
+
+    def replace(
+        self, index: UInt64 | int, value: _TArrayItem
+    ) -> "FixedArray[_TArrayItem, _TArrayLength]":
+        copied = list(self._items)
+        copied[int(index)] = value
+        return self._from_iter(copied)
+
+    def copy(self) -> typing.Self:
+        return self.__class__.from_bytes(self.serialize())
+
+    def freeze(self) -> ImmutableFixedArray[_TArrayItem, _TArrayLength]:
+        return ImmutableFixedArray(self._items)
+
+    def _from_iter(self, items: Iterable[_TArrayItem]) -> "FixedArray[_TArrayItem, _TArrayLength]":
+        el_type = self._element_type
+        l_type = self._length
+        typ = FixedArray[el_type, l_type]  # type: ignore[valid-type]
+        return typ(items)
+
+    def serialize(self) -> bytes:
+        return serialize_to_bytes(self)
+
+    @classmethod
+    def from_bytes(cls, value: bytes, /) -> typing.Self:
+        return deserialize_from_bytes(cls, value)
+
+
 class _ImmutableArrayMeta(type):
     __concrete__: typing.ClassVar[dict[type, type]] = {}
 
@@ -30,11 +278,13 @@ def __getitem__(cls, element_t: type) -> type:
         return c
 
 
-class ImmutableArray(Serializable, typing.Generic[_T], metaclass=_ImmutableArrayMeta):
+class ImmutableArray(
+    Serializable, MutableBytes, typing.Generic[_TArrayItem], metaclass=_ImmutableArrayMeta
+):
     _element_type: typing.ClassVar[type]
 
     # ensure type is fully parameterized by looking up type from metaclass
-    def __new__(cls, *items: _T) -> typing.Self:
+    def __new__(cls, *items: _TArrayItem) -> typing.Self:
         from _algopy_testing.serialize import type_of
 
         try:
@@ -48,44 +298,55 @@ def __new__(cls, *items: _T) -> typing.Self:
         instance = super().__new__(cls)
         return instance
 
-    def __init__(self, *items: _T):
+    def __init__(self, *items: _TArrayItem):
+        super().__init__()
         for item in items:
             if not isinstance(item, typing.get_origin(self._element_type) or self._element_type):
                 raise TypeError(f"expected items of type {self._element_type}")
-        self._items = tuple(items)
+        self._items = list(items)
+        self._value = serialize_to_bytes(self)
 
-    def __iter__(self) -> Iterator[_T]:
+    def __iter__(self) -> Iterator[_TArrayItem]:
         return iter(self._items)
 
-    def __reversed__(self) -> Iterator[_T]:
+    def __reversed__(self) -> Iterator[_TArrayItem]:
         return reversed(self._items)
 
     @property
     def length(self) -> UInt64:
         return UInt64(len(self._items))
 
-    def __getitem__(self, index: UInt64 | int) -> _T:
-        return self._items[index]
+    def __len__(self) -> UInt64:
+        return self.length
+
+    def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
+        value = self._items[index]
+        return set_item_on_mutate(self, index, value)
+
+    def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
+        self._items[int(index)] = value
+        self._value = serialize_to_bytes(self)
+        return value
 
-    def replace(self, index: UInt64 | int, value: _T) -> "ImmutableArray[_T]":
+    def replace(self, index: UInt64 | int, value: _TArrayItem) -> "ImmutableArray[_TArrayItem]":
         copied = list(self._items)
         copied[int(index)] = value
         return self._from_iter(copied)
 
-    def append(self, item: _T, /) -> "ImmutableArray[_T]":
+    def append(self, item: _TArrayItem, /) -> "ImmutableArray[_TArrayItem]":
         copied = list(self._items)
         copied.append(item)
         return self._from_iter(copied)
 
-    def __add__(self, other: Iterable[_T], /) -> "ImmutableArray[_T]":
+    def __add__(self, other: Iterable[_TArrayItem], /) -> "ImmutableArray[_TArrayItem]":
         return self._from_iter((*self._items, *other))
 
-    def pop(self) -> "ImmutableArray[_T]":
+    def pop(self) -> "ImmutableArray[_TArrayItem]":
         copied = list(self._items)
         copied.pop()
         return self._from_iter(copied)
 
-    def _from_iter(self, items: Iterable[_T]) -> "ImmutableArray[_T]":
+    def _from_iter(self, items: Iterable[_TArrayItem]) -> "ImmutableArray[_TArrayItem]":
         """Returns a new array populated with items, also ensures element type info is
         preserved."""
         el_type = self._element_type
@@ -103,42 +364,201 @@ def from_bytes(cls, value: bytes, /) -> typing.Self:
         return deserialize_from_bytes(cls, value)
 
 
-class Array(Reversible[_T]):
-
-    def __init__(self, *items: _T):
+class ReferenceArray(Reversible[_TArrayItem]):
+    def __init__(self, *items: _TArrayItem):
         self._items = list(items)
 
-    def __iter__(self) -> Iterator[_T]:
+    def __iter__(self) -> Iterator[_TArrayItem]:
         return iter(list(self._items))
 
-    def __reversed__(self) -> Iterator[_T]:
+    def __reversed__(self) -> Iterator[_TArrayItem]:
         return reversed(self._items)
 
     @property
     def length(self) -> UInt64:
         return UInt64(len(self._items))
 
-    def __getitem__(self, index: UInt64 | int) -> _T:
+    def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
         return self._items[int(index)]
 
-    def __setitem__(self, index: UInt64 | int, value: _T) -> _T:
+    def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
         self._items[int(index)] = value
         return value
 
-    def append(self, item: _T, /) -> None:
+    def append(self, item: _TArrayItem, /) -> None:
         self._items.append(item)
 
-    def extend(self, other: Iterable[_T], /) -> None:
+    def extend(self, other: Iterable[_TArrayItem], /) -> None:
         self._items.extend(other)
 
-    def pop(self) -> _T:
+    def pop(self) -> _TArrayItem:
         return self._items.pop()
 
-    def copy(self) -> "Array[_T]":
-        return Array(*self._items)
+    def copy(self) -> "ReferenceArray[_TArrayItem]":
+        return ReferenceArray(*self._items)
 
-    def freeze(self) -> ImmutableArray[_T]:
+    def freeze(self) -> ImmutableArray[_TArrayItem]:
         return ImmutableArray(*self._items)
 
     def __bool__(self) -> bool:
         return bool(self._items)
+
+
+class _ArrayMeta(type):
+    __concrete__: typing.ClassVar[dict[type, type]] = {}
+
+    # get or create a type that is parametrized with element_t
+    def __getitem__(cls, element_t: type) -> type:
+        cache = cls.__concrete__
+        if c := cache.get(element_t, None):
+            return c
+
+        cls_name = f"{cls.__name__}[{element_t.__name__}]"
+        cache[element_t] = c = types.new_class(
+            cls_name,
+            bases=(cls,),
+            exec_body=lambda ns: ns.update(
+                _element_type=element_t,
+            ),
+        )
+
+        return c
+
+
+class Array(Serializable, MutableBytes, typing.Generic[_TArrayItem], metaclass=_ArrayMeta):
+    """A dynamically sized Array of the specified type."""
+
+    _element_type: typing.ClassVar[type]
+
+    # ensure type is fully parameterized by looking up type from metaclass
+    def __new__(cls, values: Iterable[_TArrayItem]) -> typing.Self:
+        from _algopy_testing.serialize import type_of
+
+        try:
+            assert cls._element_type
+        except AttributeError:
+            try:
+                items = list(values)
+                item = items[0]
+            except IndexError:
+                raise TypeError("array must have an item type") from None
+            cls = cls[type_of(item)]
+        instance = super().__new__(cls)
+        return instance
+
+    def __init__(self, values: Iterable[_TArrayItem]) -> None:
+        super().__init__()
+        for item in values:
+            if not isinstance(item, typing.get_origin(self._element_type) or self._element_type):
+                raise TypeError(f"expected items of type {self._element_type}")
+        self._items = list(values)
+        self._value = serialize_to_bytes(self)
+
+    def __iter__(self) -> typing.Iterator[_TArrayItem]:
+        return iter(self._items)
+
+    def __reversed__(self) -> typing.Iterator[_TArrayItem]:
+        return reversed(self._items)
+
+    @property
+    def length(self) -> UInt64:
+        return UInt64(len(self._items))
+
+    def __len__(self) -> UInt64:
+        return self.length
+
+    def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
+        value = self._items[index]
+        return set_item_on_mutate(self, index, value)
+
+    def append(self, item: _TArrayItem, /) -> None:
+        self._items.append(item)
+
+    def extend(self, other: Iterable[_TArrayItem], /) -> None:
+        self._items.extend(other)
+
+    def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
+        self._items[index] = value
+        self._value = serialize_to_bytes(self)
+        return value
+
+    def __add__(self, other: Iterable[_TArrayItem]) -> "Array[_TArrayItem]":
+        return self._from_iter((*self._items, *other))
+
+    def pop(self) -> _TArrayItem:
+        return self._items.pop()
+
+    def copy(self) -> typing.Self:
+        return self.__class__.from_bytes(self.serialize())
+
+    def freeze(self) -> ImmutableArray[_TArrayItem]:
+        return ImmutableArray(*self._items)
+
+    def _from_iter(self, items: Iterable[_TArrayItem]) -> "Array[_TArrayItem]":
+        """Returns a new array populated with items, also ensures element type info is
+        preserved."""
+        el_type = self._element_type
+        typ = Array[el_type]  # type: ignore[valid-type]
+        return typ(items)
+
+    def __bool__(self) -> bool:
+        return bool(self._items)
+
+    def serialize(self) -> bytes:
+        return serialize_to_bytes(self)
+
+    @classmethod
+    def from_bytes(cls, value: bytes, /) -> typing.Self:
+        return deserialize_from_bytes(cls, value)
+
+
+@typing.dataclass_transform()
+class Struct(Serializable, MutableBytes):
+    """Base class for Struct types."""
+
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: dict[str, typing.Any]) -> None:
+        # make implementation not frozen, so we can conditionally control behaviour
+        dataclasses.dataclass(cls, *args, **{**kwargs, "frozen": False})
+        frozen = kwargs.get("frozen", False)
+        assert isinstance(frozen, bool)
+
+    def __post_init__(self) -> None:
+        # calling base class here to init Mutable
+        # see https://docs.python.org/3/library/dataclasses.html#post-init-processing
+        super().__init__()
+
+    def __getattribute__(self, name: str) -> typing.Any:
+        value = super().__getattribute__(name)
+        return add_mutable_callback(lambda _: self._update_backing_value(), value)
+
+    def copy(self) -> typing.Self:
+        return self.__class__.from_bytes(self.serialize())
+
+    def _replace(self, **kwargs: typing.Any) -> typing.Self:
+        return self.__class__(**{**self.__dict__, **kwargs})
+
+    def serialize(self) -> bytes:
+        return serialize_to_bytes(self)
+
+    @classmethod
+    def from_bytes(cls, value: bytes, /) -> typing.Self:
+        return deserialize_from_bytes(cls, value)
+
+    def _update_backing_value(self) -> None:
+        self._value = serialize_to_bytes(self)
+
+
+def zero_bytes(typ: type[_T]) -> _T:
+    # Get the static size of the type
+    size = get_static_size_of(typ)
+    if size is None:
+        raise ValueError(f"{typ} is dynamically sized")
+
+    # Create zero bytes of the required size
+    zero_data = bytes(size)
+
+    # Use the type's from_bytes method to create the instance
+    if hasattr(typ, "from_bytes"):
+        return typ.from_bytes(zero_data)  # type: ignore[attr-defined, no-any-return]
+    else:
+        raise TypeError(f"Type {typ} does not support from_bytes method")
diff --git a/src/_algopy_testing/serialize.py b/src/_algopy_testing/serialize.py
index 25e29a2a..fd5b86fd 100644
--- a/src/_algopy_testing/serialize.py
+++ b/src/_algopy_testing/serialize.py
@@ -5,6 +5,7 @@
 from collections.abc import Callable, Sequence
 
 from _algopy_testing.primitives.uint64 import UInt64
+from _algopy_testing.utils import get_type_generic_from_int_literal
 
 if typing.TYPE_CHECKING:
     from _algopy_testing.arc4 import _ABIEncoded
@@ -25,9 +26,17 @@ def identity(i: _T) -> _T:
     return i
 
 
-def get_native_to_arc4_serializer(typ: type) -> _Serializer[typing.Any, typing.Any]:
+def get_native_to_arc4_serializer(  # noqa: PLR0911
+    typ: type,
+) -> _Serializer[typing.Any, typing.Any]:
     from _algopy_testing import arc4
-    from _algopy_testing.primitives import ImmutableArray
+    from _algopy_testing.primitives import (
+        Array,
+        FixedArray,
+        ImmutableArray,
+        ImmutableFixedArray,
+        Struct,
+    )
     from _algopy_testing.protocols import UInt64Backed
 
     origin_type = typing.get_origin(typ)
@@ -54,7 +63,9 @@ def get_native_to_arc4_serializer(typ: type) -> _Serializer[typing.Any, typing.A
             if any(isinstance(f, str) for f in tuple_fields):
                 raise TypeError("string annotations in typing.NamedTuple fields are not supported")
             return _get_tuple_serializer(tuple_fields)
-        if issubclass(typ, ImmutableArray):
+        if issubclass(typ, Struct):
+            return _get_struct_serializer(typ)
+        if issubclass(typ, Array | ImmutableArray):
             native_element_type = typ._element_type
             element_serializer = get_native_to_arc4_serializer(native_element_type)
             arc4_element_type = element_serializer.arc4_type
@@ -62,10 +73,27 @@ def get_native_to_arc4_serializer(typ: type) -> _Serializer[typing.Any, typing.A
             return _Serializer(
                 arc4_type=arc4_type,
                 native_to_arc4=lambda arr: arc4_type(
-                    *(element_serializer.native_to_arc4(e) for e in arr)
+                    *[element_serializer.native_to_arc4(e) for e in arr]
+                ),
+                arc4_to_native=lambda arr: (
+                    typ([element_serializer.arc4_to_native(e) for e in arr])
+                    if issubclass(typ, Array)
+                    else typ(*[element_serializer.arc4_to_native(e) for e in arr])
+                ),
+            )
+        if issubclass(typ, FixedArray | ImmutableFixedArray):
+            native_element_type = typ._element_type
+            length_type = get_type_generic_from_int_literal(typ._length)
+            element_serializer = get_native_to_arc4_serializer(native_element_type)
+            arc4_element_type = element_serializer.arc4_type
+            arc4_fixed_type = arc4.StaticArray[arc4_element_type, length_type]  # type: ignore[valid-type]
+            return _Serializer(
+                arc4_type=arc4_fixed_type,
+                native_to_arc4=lambda arr: arc4_fixed_type(
+                    *[element_serializer.native_to_arc4(e) for e in arr]
                 ),
                 arc4_to_native=lambda arr: typ(
-                    *(element_serializer.arc4_to_native(e) for e in arr)
+                    [element_serializer.arc4_to_native(e) for e in arr]
                 ),
             )
     raise TypeError(f"unserializable type: {typ}")
@@ -111,6 +139,36 @@ def _items_to_native(items: Sequence[object]) -> tuple[object, ...]:
     )
 
 
+def _get_struct_serializer(typ: type) -> _Serializer[typing.Any, typing.Any]:
+    from _algopy_testing import arc4
+
+    struct_fields = inspect.get_annotations(typ)
+    serializers = {k: get_native_to_arc4_serializer(v) for k, v in struct_fields.items()}
+
+    def _items_to_arc4(items: object) -> dict[str, object]:
+        result = {}
+        for key in inspect.get_annotations(type(items)):
+            serializer = serializers[key]
+            result[key] = serializer.native_to_arc4(getattr(items, key))
+        return result
+
+    def _items_to_native(items: object) -> dict[str, object]:
+        result = {}
+        for key in inspect.get_annotations(type(items)):
+            serializer = serializers[key]
+            result[key] = serializer.arc4_to_native(getattr(items, key))
+        return result
+
+    class TempStruct(arc4.Struct):
+        __annotations__ = {k: s.arc4_type for k, s in serializers.items()}
+
+    return _Serializer(
+        arc4_type=TempStruct,
+        native_to_arc4=lambda t: TempStruct(**_items_to_arc4(t)),
+        arc4_to_native=lambda t: typ(**_items_to_native(t)),
+    )
+
+
 def serialize_to_bytes(value: object) -> bytes:
     return native_to_arc4(value).bytes.value
 
diff --git a/src/_algopy_testing/utils.py b/src/_algopy_testing/utils.py
index c983336b..de25df86 100644
--- a/src/_algopy_testing/utils.py
+++ b/src/_algopy_testing/utils.py
@@ -213,3 +213,22 @@ def get_static_size_of(typ: type | object, /) -> int | None:
     size = get_max_bytes_static_len(type_info)
 
     return size
+
+
+def get_int_literal_from_type_generic(literal_type: type) -> int:
+    type_args = typing.get_args(literal_type)
+    try:
+        (int_arg,) = type_args
+    except ValueError:
+        int_arg = 0
+    return int(int_arg)
+
+
+def get_type_generic_from_int_literal(value: int) -> type:
+    return typing.cast("type", typing.Literal[value])
+
+
+def parameterize_type(type_: type, *params: type) -> type:
+    if len(params) == 1:
+        return typing.cast("type", type_[params[0]])  # type: ignore[index]
+    return typing.cast("type", type_[params])  # type: ignore[index]
diff --git a/src/algopy/__init__.py b/src/algopy/__init__.py
index 029b6d54..9234545b 100644
--- a/src/algopy/__init__.py
+++ b/src/algopy/__init__.py
@@ -14,7 +14,19 @@
 from _algopy_testing.models.template_variable import TemplateVar
 from _algopy_testing.models.unsigned_builtins import uenumerate, urange
 from _algopy_testing.op import Global, Txn
-from _algopy_testing.primitives import Array, BigUInt, Bytes, ImmutableArray, String, UInt64
+from _algopy_testing.primitives import (
+    Array,
+    BigUInt,
+    Bytes,
+    FixedArray,
+    ImmutableArray,
+    ImmutableFixedArray,
+    ReferenceArray,
+    String,
+    Struct,
+    UInt64,
+    zero_bytes,
+)
 from _algopy_testing.protocols import BytesBacked
 from _algopy_testing.state import Box, BoxMap, BoxRef, GlobalState, LocalState
 from _algopy_testing.utilities import OpUpFeeSource, ensure_budget, log, size_of
@@ -36,15 +48,19 @@
     "CompiledContract",
     "CompiledLogicSig",
     "Contract",
+    "FixedArray",
     "Global",
     "GlobalState",
     "ImmutableArray",
+    "ImmutableFixedArray",
     "LocalState",
     "LogicSig",
     "OnCompleteAction",
     "OpUpFeeSource",
+    "ReferenceArray",
     "StateTotals",
     "String",
+    "Struct",
     "TemplateVar",
     "TransactionType",
     "Txn",
@@ -58,8 +74,9 @@
     "log",
     "logicsig",
     "op",
-    "subroutine",
     "size_of",
+    "subroutine",
     "uenumerate",
     "urange",
+    "zero_bytes",
 ]
diff --git a/tests/arc4/test_address.py b/tests/arc4/test_address.py
index c80e3eb7..b0659fb0 100644
--- a/tests/arc4/test_address.py
+++ b/tests/arc4/test_address.py
@@ -246,3 +246,10 @@ def test_comparison_with_other_from_account(value: bytes, other: bytes) -> None:
     assert arc4_value != other_account
 
     assert arc4_value != arc4.Address(algopy.Bytes(other))
+
+
+def test_to_native() -> None:
+    a1 = arc4.Address("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ")
+    native_a1 = a1.to_native(arc4.Byte)
+    assert native_a1.length == 32
+    assert [x.native for x in native_a1] == [0] * 32
diff --git a/tests/arc4/test_dynamic_array.py b/tests/arc4/test_dynamic_array.py
index 0207db12..2f9dbb65 100644
--- a/tests/arc4/test_dynamic_array.py
+++ b/tests/arc4/test_dynamic_array.py
@@ -3,6 +3,8 @@
 
 import pytest
 from _algopy_testing import arc4
+from _algopy_testing.primitives import BigUInt, String, UInt64
+from _algopy_testing.primitives.array import Array, ImmutableArray
 from algosdk import abi
 
 from tests.util import int_to_bytes
@@ -1026,6 +1028,59 @@ def test_add(
     assert abi_result == arc4_result
 
 
+def test_to_native() -> None:
+    arr1 = arc4.DynamicArray[arc4.Bool](
+        arc4.Bool(True),
+        arc4.Bool(False),
+        arc4.Bool(False),
+        arc4.Bool(True),
+        arc4.Bool(False),
+        arc4.Bool(True),
+        arc4.Bool(True),
+        arc4.Bool(False),
+        arc4.Bool(True),
+        arc4.Bool(False),
+    )
+    native_arr1 = arr1.to_native(bool)
+    assert native_arr1.length == 10
+    assert list(native_arr1) == [True, False, False, True, False, True, True, False, True, False]
+
+    arr2 = arc4.DynamicArray[arc4.UInt64](*[arc4.UInt64(i) for i in range(1, 11)])
+    native_arr2 = arr2.to_native(UInt64)
+    assert native_arr2.length == 10
+    assert list(native_arr2) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    arr3 = arc4.DynamicArray[arc4.UInt512](*[arc4.UInt512(i) for i in range(1, 11)])
+    native_arr3 = arr3.to_native(BigUInt)
+    assert native_arr3.length == 10
+    assert list(native_arr3) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    arr4 = arc4.DynamicArray[arc4.String](*[arc4.String(f"string_{i}") for i in range(1, 11)])
+    native_arr4 = arr4.to_native(String)
+    assert native_arr4.length == 10
+    assert list(native_arr4) == [f"string_{i}" for i in range(1, 11)]
+
+    arr5 = arc4.DynamicArray[arc4.DynamicArray[arc4.UInt64]](
+        *[
+            arc4.DynamicArray[arc4.UInt64](*[arc4.UInt64(i) for i in range(1, 11)]),
+            arc4.DynamicArray[arc4.UInt64](*[arc4.UInt64(i) for i in range(21, 31)]),
+        ]
+    )
+    native_arr5 = arr5.to_native(Array[UInt64])
+    assert native_arr5.length == 2
+    assert native_arr5[0].length == 10
+    assert native_arr5[1].length == 10
+    assert list(native_arr5[0]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert list(native_arr5[1]) == [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
+
+    imm_native_arr5 = arr5.to_native(ImmutableArray[UInt64])
+    assert imm_native_arr5.length == 2
+    assert imm_native_arr5[0].length == 10
+    assert imm_native_arr5[1].length == 10
+    assert list(imm_native_arr5[0]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert list(imm_native_arr5[1]) == [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
+
+
 def _compare_abi_and_arc4_values(
     arc4_value: typing.Any,
     abi_value: typing.Any,
diff --git a/tests/arc4/test_static_array.py b/tests/arc4/test_static_array.py
index 1bfcbe83..d58a64eb 100644
--- a/tests/arc4/test_static_array.py
+++ b/tests/arc4/test_static_array.py
@@ -3,6 +3,8 @@
 
 import pytest
 from _algopy_testing import arc4
+from _algopy_testing.primitives import BigUInt, String, UInt64
+from _algopy_testing.primitives.array import FixedArray, ImmutableFixedArray
 from algosdk import abi
 
 from tests.util import int_to_bytes
@@ -559,3 +561,66 @@ def _compare_abi_and_arc4_values(
         assert arc4_value.native == abi_value
     else:
         assert arc4_value.bytes == int_to_bytes(abi_value, len(arc4_value.bytes))
+
+
+def test_to_native() -> None:
+    arr1 = arc4.StaticArray[arc4.Bool, typing.Literal[10]](
+        arc4.Bool(True),
+        arc4.Bool(False),
+        arc4.Bool(False),
+        arc4.Bool(True),
+        arc4.Bool(False),
+        arc4.Bool(True),
+        arc4.Bool(True),
+        arc4.Bool(False),
+        arc4.Bool(True),
+        arc4.Bool(False),
+    )
+    native_arr1 = arr1.to_native(bool)
+    assert native_arr1.length == 10
+    assert list(native_arr1) == [True, False, False, True, False, True, True, False, True, False]
+
+    arr2 = arc4.StaticArray[arc4.UInt64, typing.Literal[10]](
+        *[arc4.UInt64(i) for i in range(1, 11)]
+    )
+    native_arr2 = arr2.to_native(UInt64)
+    assert native_arr2.length == 10
+    assert list(native_arr2) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    arr3 = arc4.StaticArray[arc4.UInt512, typing.Literal[10]](
+        *[arc4.UInt512(i) for i in range(1, 11)]
+    )
+    native_arr3 = arr3.to_native(BigUInt)
+    assert native_arr3.length == 10
+    assert list(native_arr3) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    arr4 = arc4.StaticArray[arc4.String, typing.Literal[10]](
+        *[arc4.String(f"string_{i}") for i in range(1, 11)]
+    )
+    native_arr4 = arr4.to_native(String)
+    assert native_arr4.length == 10
+    assert list(native_arr4) == [f"string_{i}" for i in range(1, 11)]
+
+    arr5 = arc4.StaticArray[arc4.StaticArray[arc4.UInt64, typing.Literal[10]], typing.Literal[2]](
+        *[
+            arc4.StaticArray[arc4.UInt64, typing.Literal[10]](
+                *[arc4.UInt64(i) for i in range(1, 11)]
+            ),
+            arc4.StaticArray[arc4.UInt64, typing.Literal[10]](
+                *[arc4.UInt64(i) for i in range(21, 31)]
+            ),
+        ]
+    )
+    native_arr5 = arr5.to_native(FixedArray[UInt64, typing.Literal[10]])
+    assert native_arr5.length == 2
+    assert native_arr5[0].length == 10
+    assert native_arr5[1].length == 10
+    assert list(native_arr5[0]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert list(native_arr5[1]) == [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
+
+    imm_native_arr5 = arr5.to_native(ImmutableFixedArray[UInt64, typing.Literal[10]])
+    assert imm_native_arr5.length == 2
+    assert imm_native_arr5[0].length == 10
+    assert imm_native_arr5[1].length == 10
+    assert list(imm_native_arr5[0]) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    assert list(imm_native_arr5[1]) == [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
index a6b7daf8..fd0e78b6 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
@@ -504,11 +504,13 @@ complex_sig:
     dig 2
     substring3
     dup
-    extract 0 8 // on error: Index access is out of bounds
+    extract 0 8
     bytec_1 // 0x0000000000000001
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:90
+    // tests/artifacts/Arc4ABIMethod/contract.py:88-90
+    // # struct
+    // assert struct1.another_struct.one == 1
     // assert struct1.another_struct.two == "2"
     dup
     pushint 8 // 8
@@ -518,6 +520,8 @@ complex_sig:
     dig 2
     cover 2
     substring3
+    // tests/artifacts/Arc4ABIMethod/contract.py:90
+    // assert struct1.another_struct.two == "2"
     bytec_2 // 0x000132
     ==
     assert
@@ -530,11 +534,12 @@ complex_sig:
     uncover 2
     substring3
     dup
-    extract 0 8 // on error: Index access is out of bounds
+    extract 0 8
     bytec_1 // 0x0000000000000001
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:92
+    // tests/artifacts/Arc4ABIMethod/contract.py:91-92
+    // assert struct1.another_struct_alias.one == 1
     // assert struct1.another_struct_alias.two == "2"
     dup
     pushint 8 // 8
@@ -542,20 +547,24 @@ complex_sig:
     dig 1
     len
     substring3
+    // tests/artifacts/Arc4ABIMethod/contract.py:90
+    // assert struct1.another_struct.two == "2"
     bytec_2 // 0x000132
+    // tests/artifacts/Arc4ABIMethod/contract.py:92
+    // assert struct1.another_struct_alias.two == "2"
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:93
     // assert struct1.three == 3
     frame_dig -4
-    extract 4 16 // on error: Index access is out of bounds
+    extract 4 16
     pushbytes 0x00000000000000000000000000000003
     b==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:94
     // assert struct1.four == 4
     frame_dig -4
-    extract 20 16 // on error: Index access is out of bounds
+    extract 20 16
     pushbytes 0x00000000000000000000000000000004
     b==
     assert
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
index 2979e0e3..a3b24344 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
@@ -65,7 +65,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@14
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10

main_after_if_else@14:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_complex_sig_route@10:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
    // @arc4.abimethod
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
    // @arc4.abimethod
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // tests/artifacts/Arc4ABIMethod/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
    // @arc4.abimethod
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
    // @arc4.abimethod
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // tests/artifacts/Arc4ABIMethod/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8 // on error: Index access is out of bounds
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8 // on error: Index access is out of bounds
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16 // on error: Index access is out of bounds
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16 // on error: Index access is out of bounds
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@14
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10

main_after_if_else@14:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_complex_sig_route@10:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
    // @arc4.abimethod
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
    // @arc4.abimethod
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // tests/artifacts/Arc4ABIMethod/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
    // @arc4.abimethod
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
    // @arc4.abimethod
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // tests/artifacts/Arc4ABIMethod/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-90
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91-92
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json
index 7f571d34..c4aca8f5 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json
@@ -286,15 +286,6 @@
     "sourceInfo": {
         "approval": {
             "sourceInfo": [
-                {
-                    "pc": [
-                        555,
-                        587,
-                        606,
-                        631
-                    ],
-                    "errorMessage": "Index access is out of bounds"
-                },
                 {
                     "pc": [
                         98,
@@ -400,7 +391,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@14
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10

main_after_if_else@14:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_complex_sig_route@10:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
    // @arc4.abimethod
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
    // @arc4.abimethod
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // tests/artifacts/Arc4ABIMethod/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
    // @arc4.abimethod
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
    // @arc4.abimethod
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // tests/artifacts/Arc4ABIMethod/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8 // on error: Index access is out of bounds
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8 // on error: Index access is out of bounds
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16 // on error: Index access is out of bounds
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16 // on error: Index access is out of bounds
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@14
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10

main_after_if_else@14:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_complex_sig_route@10:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
    // @arc4.abimethod
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
    // @arc4.abimethod
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // tests/artifacts/Arc4ABIMethod/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
    // @arc4.abimethod
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
    // @arc4.abimethod
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // tests/artifacts/Arc4ABIMethod/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-90
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91-92
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
@@ -411,8 +402,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc56.json b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc56.json
index 5a434b60..e992385f 100644
--- a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc56.json
+++ b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc56.json
@@ -98,8 +98,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal
index e4de881f..c628f307 100644
--- a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal
+++ b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal
@@ -118,12 +118,16 @@ main_verify_bool_bytes_route@45:
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    pushbytes 0x0001
     // tests/artifacts/Arc4PrimitiveOps/contract.py:6
     // class Arc4PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     // tests/artifacts/Arc4PrimitiveOps/contract.py:240
     // @arc4.abimethod()
+    dup
+    len
+    itob
+    extract 6 2
+    swap
     concat
     bytec_0 // 0x151f7c75
     swap
@@ -367,12 +371,16 @@ main_verify_bigufixednxm_bytes_route@34:
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    pushbytes 0x0020
     // tests/artifacts/Arc4PrimitiveOps/contract.py:6
     // class Arc4PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     // tests/artifacts/Arc4PrimitiveOps/contract.py:183
     // @arc4.abimethod()
+    dup
+    len
+    itob
+    extract 6 2
+    swap
     concat
     bytec_0 // 0x151f7c75
     swap
@@ -389,12 +397,16 @@ main_verify_ufixednxm_bytes_route@33:
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    pushbytes 0x0004
     // tests/artifacts/Arc4PrimitiveOps/contract.py:6
     // class Arc4PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     // tests/artifacts/Arc4PrimitiveOps/contract.py:177
     // @arc4.abimethod()
+    dup
+    len
+    itob
+    extract 6 2
+    swap
     concat
     bytec_0 // 0x151f7c75
     swap
@@ -2083,17 +2095,17 @@ verify_string_add:
     proto 2 1
     // tests/artifacts/Arc4PrimitiveOps/contract.py:220
     // result = a + b
-    frame_dig -2
-    extract 2 0
     frame_dig -1
     extract 2 0
-    concat
+    frame_dig -2
+    swap
+    concat // on error: max array length exceeded
     dup
+    extract 2 0
     len
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     // tests/artifacts/Arc4PrimitiveOps/contract.py:221
     // return result
     retsub
diff --git a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json
index fb21730c..ca4e428b 100644
--- a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json
+++ b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json
@@ -232,7 +232,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 64 0
    bytecblock 0x151f7c75 0x00
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@51
    pushbytess 0x96f14116 0xed666096 0x2ca0352b 0x85907d40 0x2cbec45b 0x07666fd9 0x370babd3 0x2b6b3ef0 0x339da97c 0x7898ed97 0x1f130cec 0xc748664e 0x7a460cb1 0xdcab1f01 0x97d9064d 0xce06c2a0 0xdcdbcee0 0x77a4b68d 0x4f540626 0x095aed41 0xe3b7e918 0x55337008 0x9bb1cd66 0x81484d9d 0x9a03df10 0xd3f0e44b 0x982db233 0xaffbdf0e 0x288af76e 0x8bd84a04 0x0f1574fe 0xb2cb13be 0xd059eea7 0x4cc4c157 0x3d17ac6e 0xf7f3d5fc 0xf8c8f8d5 0x43f7162a 0x42e09075 0xd956f575 0x6c0160df 0xa890150b 0x0b2f4c3f 0x9db9d327 0xe4d950a1 0xb605e80c // method "verify_uintn_uintn_eq(byte[],byte[])bool", method "verify_biguintn_uintn_eq(byte[],byte[])bool", method "verify_uintn_biguintn_eq(byte[],byte[])bool", method "verify_biguintn_biguintn_eq(byte[],byte[])bool", method "verify_uintn_uintn_ne(byte[],byte[])bool", method "verify_biguintn_uintn_ne(byte[],byte[])bool", method "verify_uintn_biguintn_ne(byte[],byte[])bool", method "verify_biguintn_biguintn_ne(byte[],byte[])bool", method "verify_uintn_uintn_lt(byte[],byte[])bool", method "verify_biguintn_uintn_lt(byte[],byte[])bool", method "verify_uintn_biguintn_lt(byte[],byte[])bool", method "verify_biguintn_biguintn_lt(byte[],byte[])bool", method "verify_uintn_uintn_le(byte[],byte[])bool", method "verify_biguintn_uintn_le(byte[],byte[])bool", method "verify_uintn_biguintn_le(byte[],byte[])bool", method "verify_biguintn_biguintn_le(byte[],byte[])bool", method "verify_uintn_uintn_gt(byte[],byte[])bool", method "verify_biguintn_uintn_gt(byte[],byte[])bool", method "verify_uintn_biguintn_gt(byte[],byte[])bool", method "verify_biguintn_biguintn_gt(byte[],byte[])bool", method "verify_uintn_uintn_ge(byte[],byte[])bool", method "verify_biguintn_uintn_ge(byte[],byte[])bool", method "verify_uintn_biguintn_ge(byte[],byte[])bool", method "verify_biguintn_biguintn_ge(byte[],byte[])bool", method "verify_uintn_init(byte[])uint32", method "verify_biguintn_init(byte[])uint256", method "verify_uintn_from_bytes(byte[])uint32", method "verify_biguintn_from_bytes(byte[])uint256", method "verify_uintn_from_log(byte[])uint32", method "verify_biguintn_from_log(byte[])uint256", method "verify_ufixednxm_bytes(ufixed32x8)byte[]", method "verify_bigufixednxm_bytes(ufixed256x16)byte[]", method "verify_ufixednxm_from_bytes(byte[])ufixed32x8", method "verify_bigufixednxm_from_bytes(byte[])ufixed256x16", method "verify_ufixednxm_from_log(byte[])ufixed32x8", method "verify_bigufixednxm_from_log(byte[])ufixed256x16", method "verify_string_init(string)string", method "verify_string_add(string,string)string", method "verify_string_eq(string,string)bool", method "verify_string_bytes(string)byte[]", method "verify_string_from_bytes(byte[])string", method "verify_string_from_log(byte[])string", method "verify_bool_bytes(bool)byte[]", method "verify_bool_from_bytes(byte[])bool", method "verify_bool_from_log(byte[])bool", method "verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_uintn_uintn_eq_route@3 main_verify_biguintn_uintn_eq_route@4 main_verify_uintn_biguintn_eq_route@5 main_verify_biguintn_biguintn_eq_route@6 main_verify_uintn_uintn_ne_route@7 main_verify_biguintn_uintn_ne_route@8 main_verify_uintn_biguintn_ne_route@9 main_verify_biguintn_biguintn_ne_route@10 main_verify_uintn_uintn_lt_route@11 main_verify_biguintn_uintn_lt_route@12 main_verify_uintn_biguintn_lt_route@13 main_verify_biguintn_biguintn_lt_route@14 main_verify_uintn_uintn_le_route@15 main_verify_biguintn_uintn_le_route@16 main_verify_uintn_biguintn_le_route@17 main_verify_biguintn_biguintn_le_route@18 main_verify_uintn_uintn_gt_route@19 main_verify_biguintn_uintn_gt_route@20 main_verify_uintn_biguintn_gt_route@21 main_verify_biguintn_biguintn_gt_route@22 main_verify_uintn_uintn_ge_route@23 main_verify_biguintn_uintn_ge_route@24 main_verify_uintn_biguintn_ge_route@25 main_verify_biguintn_biguintn_ge_route@26 main_verify_uintn_init_route@27 main_verify_biguintn_init_route@28 main_verify_uintn_from_bytes_route@29 main_verify_biguintn_from_bytes_route@30 main_verify_uintn_from_log_route@31 main_verify_biguintn_from_log_route@32 main_verify_ufixednxm_bytes_route@33 main_verify_bigufixednxm_bytes_route@34 main_verify_ufixednxm_from_bytes_route@35 main_verify_bigufixednxm_from_bytes_route@36 main_verify_ufixednxm_from_log_route@37 main_verify_bigufixednxm_from_log_route@38 main_verify_string_init_route@39 main_verify_string_add_route@40 main_verify_string_eq_route@41 main_verify_string_bytes_route@42 main_verify_string_from_bytes_route@43 main_verify_string_from_log_route@44 main_verify_bool_bytes_route@45 main_verify_bool_from_bytes_route@46 main_verify_bool_from_log_route@47 main_verify_emit_route@48

main_after_if_else@55:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    intc_3 // 0
    return

main_verify_emit_route@48:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    txna ApplicationArgs 12
    txna ApplicationArgs 13
    txna ApplicationArgs 14
    extract 2 0
    txna ApplicationArgs 15
    dup
    intc_3 // 0
    extract_uint16
    dig 1
    pushint 2 // 2
    extract_uint16
    substring3
    extract 2 0
    txna ApplicationArgs 15
    dup
    pushint 2 // 2
    extract_uint16
    dig 1
    len
    substring3
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    callsub verify_emit
    intc_0 // 1
    return

main_verify_bool_from_log_route@47:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    callsub verify_bool_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_from_bytes_route@46:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_bytes_route@45:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    pushbytes 0x0001
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_log_route@44:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    callsub verify_string_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_bytes_route@43:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_bytes_route@42:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    callsub verify_string_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_eq_route@41:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    callsub verify_string_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_add_route@40:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    callsub verify_string_add
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_init_route@39:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    callsub verify_string_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_log_route@38:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    callsub verify_bigufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_log_route@37:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    callsub verify_ufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_bytes_route@36:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_bytes_route@35:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_bytes_route@34:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    pushbytes 0x0020
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_bytes_route@33:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    pushbytes 0x0004
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_log_route@32:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    callsub verify_biguintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_log_route@31:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    callsub verify_uintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_bytes_route@30:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_bytes_route@29:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_init_route@28:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_biguintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_init_route@27:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_uintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ge_route@26:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ge_route@25:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ge_route@24:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ge_route@23:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_gt_route@22:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_gt_route@21:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_gt_route@20:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_gt_route@19:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_uintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_le_route@18:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_le_route@17:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_le_route@16:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_le_route@15:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    callsub verify_uintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_lt_route@14:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_lt_route@13:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_lt_route@12:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_lt_route@11:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_uintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ne_route@10:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ne_route@9:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ne_route@8:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ne_route@7:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_eq_route@6:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_eq_route@5:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_eq_route@4:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_eq_route@3:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    callsub verify_uintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@51:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@55
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7-8
    // @arc4.abimethod()
    // def verify_uintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:11
    // return arc4.UInt64(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13-14
    // @arc4.abimethod()
    // def verify_biguintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:17
    // return arc4.UInt512(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19-20
    // @arc4.abimethod()
    // def verify_uintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:23
    // return arc4.UInt64(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:29
    // return arc4.UInt512(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_uintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:35
    // return arc4.UInt64(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:41
    // return arc4.UInt512(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43-44
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:47
    // return arc4.UInt64(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49-50
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:53
    // return arc4.UInt512(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55-56
    // @arc4.abimethod()
    // def verify_uintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:59
    // return arc4.UInt64(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61-62
    // @arc4.abimethod()
    // def verify_biguintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:65
    // return arc4.UInt512(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_uintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:71
    // return arc4.UInt64(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73-74
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:77
    // return arc4.UInt512(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79-80
    // @arc4.abimethod()
    // def verify_uintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:83
    // return arc4.UInt64(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85-86
    // @arc4.abimethod()
    // def verify_biguintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:89
    // return arc4.UInt512(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_uintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:95
    // return arc4.UInt64(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97-98
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:101
    // return arc4.UInt512(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_uintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:107
    // return arc4.UInt64(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109-110
    // @arc4.abimethod()
    // def verify_biguintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:113
    // return arc4.UInt512(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115-116
    // @arc4.abimethod()
    // def verify_uintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:119
    // return arc4.UInt64(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:125
    // return arc4.UInt512(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127-128
    // @arc4.abimethod()
    // def verify_uintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:131
    // return arc4.UInt64(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133-134
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:137
    // return arc4.UInt512(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139-140
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:143
    // return arc4.UInt64(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:149
    // return arc4.UInt512(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_init(a: bytes) -> bytes:
verify_uintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_uintn_init(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:154
    // return arc4.UInt32(a_biguint)
    frame_dig -1
    len
    pushint 4 // 4
    <=
    assert // overflow
    pushint 4 // 4
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_init(a: bytes) -> bytes:
verify_biguintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_biguintn_init(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:159
    // return arc4.UInt256(a_biguint)
    frame_dig -1
    len
    pushint 32 // 32
    <=
    assert // overflow
    pushint 32 // 32
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_log(a: bytes) -> bytes:
verify_uintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169-170
    // @arc4.abimethod()
    // def verify_uintn_from_log(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:171
    // return arc4.UInt32.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_log(a: bytes) -> bytes:
verify_biguintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173-174
    // @arc4.abimethod()
    // def verify_biguintn_from_log(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:175
    // return arc4.UInt256.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_log(a: bytes) -> bytes:
verify_ufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201-204
    // @arc4.abimethod()
    // def verify_ufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:205
    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_log(a: bytes) -> bytes:
verify_bigufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207-210
    // @arc4.abimethod()
    // def verify_bigufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:211
    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_init(a: bytes) -> bytes:
verify_string_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213-214
    // @arc4.abimethod
    // def verify_string_init(self, a: String) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:215
    // result = arc4.String(String("Hello, ") + a)
    pushbytes "Hello, "
    frame_dig -1
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:216
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_add(a: bytes, b: bytes) -> bytes:
verify_string_add:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218-219
    // @arc4.abimethod
    // def verify_string_add(self, a: arc4.String, b: arc4.String) -> arc4.String:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:220
    // result = a + b
    frame_dig -2
    extract 2 0
    frame_dig -1
    extract 2 0
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:221
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_eq(a: bytes, b: bytes) -> uint64:
verify_string_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223-224
    // @arc4.abimethod()
    // def verify_string_eq(self, a: arc4.String, b: arc4.String) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:225
    // return a == b
    frame_dig -2
    frame_dig -1
    ==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_bytes(a: bytes) -> bytes:
verify_string_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227-228
    // @arc4.abimethod()
    // def verify_string_bytes(self, a: String) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:229
    // result = arc4.String(a)
    frame_dig -1
    len
    itob
    extract 6 2
    frame_dig -1
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:230
    // return result.bytes
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_log(a: bytes) -> bytes:
verify_string_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236-237
    // @arc4.abimethod()
    // def verify_string_from_log(self, a: Bytes) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:238
    // return arc4.String.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_log(a: bytes) -> bytes:
verify_bool_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248-249
    // @arc4.abimethod()
    // def verify_bool_from_log(self, a: Bytes) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:250
    // return arc4.Bool.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_emit(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes, f: bytes, g: bytes, h: bytes, m: bytes, n: bytes, o: bytes, p: bytes, q: bytes, r: bytes, s: bytes, t: bytes) -> void:
verify_emit:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252-271
    // @arc4.abimethod()
    // def verify_emit(  # noqa: PLR0913
    //     self,
    //     a: arc4.String,
    //     b: arc4.UInt512,
    //     c: arc4.UInt64,
    //     d: arc4.DynamicBytes,
    //     e: arc4.UInt64,
    //     f: arc4.Bool,
    //     g: arc4.DynamicBytes,
    //     h: arc4.String,
    //     m: arc4.UIntN[typing.Literal[64]],
    //     n: arc4.BigUIntN[typing.Literal[256]],
    //     o: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
    //     p: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
    //     q: arc4.Bool,
    //     r: Bytes,
    //     s: Bytes,
    //     t: Bytes,
    // ) -> None:
    proto 16 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:276
    // arc4.emit(SwappedArc4(m, n, o, p, q, arc4_r, arc4_s, arc4_t))
    frame_dig -8
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    pushbytes 0x0054
    concat
    frame_dig -2
    len
    pushint 84 // 84
    dig 1
    +
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0x66bb0333 // method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:277-295
    // arc4.emit(
    //     "Swapped",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    frame_dig -16
    len
    pushint 173 // 173
    +
    pushbytes 0x00ad
    frame_dig -15
    concat
    frame_dig -14
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -13
    len
    uncover 2
    +
    swap
    frame_dig -12
    concat
    frame_dig -11
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -10
    len
    uncover 2
    +
    dup
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -9
    len
    uncover 2
    +
    swap
    frame_dig -8
    concat
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    dig 1
    itob
    extract 6 2
    concat
    swap
    uncover 2
    +
    itob
    extract 6 2
    concat
    frame_dig -16
    concat
    frame_dig -13
    concat
    frame_dig -10
    concat
    frame_dig -9
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0xec3319bb // method "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    dup
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:296-314
    // arc4.emit(
    //     "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    log
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 64 0
    bytecblock 0x151f7c75 0x00
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@51
    pushbytess 0x96f14116 0xed666096 0x2ca0352b 0x85907d40 0x2cbec45b 0x07666fd9 0x370babd3 0x2b6b3ef0 0x339da97c 0x7898ed97 0x1f130cec 0xc748664e 0x7a460cb1 0xdcab1f01 0x97d9064d 0xce06c2a0 0xdcdbcee0 0x77a4b68d 0x4f540626 0x095aed41 0xe3b7e918 0x55337008 0x9bb1cd66 0x81484d9d 0x9a03df10 0xd3f0e44b 0x982db233 0xaffbdf0e 0x288af76e 0x8bd84a04 0x0f1574fe 0xb2cb13be 0xd059eea7 0x4cc4c157 0x3d17ac6e 0xf7f3d5fc 0xf8c8f8d5 0x43f7162a 0x42e09075 0xd956f575 0x6c0160df 0xa890150b 0x0b2f4c3f 0x9db9d327 0xe4d950a1 0xb605e80c // method "verify_uintn_uintn_eq(byte[],byte[])bool", method "verify_biguintn_uintn_eq(byte[],byte[])bool", method "verify_uintn_biguintn_eq(byte[],byte[])bool", method "verify_biguintn_biguintn_eq(byte[],byte[])bool", method "verify_uintn_uintn_ne(byte[],byte[])bool", method "verify_biguintn_uintn_ne(byte[],byte[])bool", method "verify_uintn_biguintn_ne(byte[],byte[])bool", method "verify_biguintn_biguintn_ne(byte[],byte[])bool", method "verify_uintn_uintn_lt(byte[],byte[])bool", method "verify_biguintn_uintn_lt(byte[],byte[])bool", method "verify_uintn_biguintn_lt(byte[],byte[])bool", method "verify_biguintn_biguintn_lt(byte[],byte[])bool", method "verify_uintn_uintn_le(byte[],byte[])bool", method "verify_biguintn_uintn_le(byte[],byte[])bool", method "verify_uintn_biguintn_le(byte[],byte[])bool", method "verify_biguintn_biguintn_le(byte[],byte[])bool", method "verify_uintn_uintn_gt(byte[],byte[])bool", method "verify_biguintn_uintn_gt(byte[],byte[])bool", method "verify_uintn_biguintn_gt(byte[],byte[])bool", method "verify_biguintn_biguintn_gt(byte[],byte[])bool", method "verify_uintn_uintn_ge(byte[],byte[])bool", method "verify_biguintn_uintn_ge(byte[],byte[])bool", method "verify_uintn_biguintn_ge(byte[],byte[])bool", method "verify_biguintn_biguintn_ge(byte[],byte[])bool", method "verify_uintn_init(byte[])uint32", method "verify_biguintn_init(byte[])uint256", method "verify_uintn_from_bytes(byte[])uint32", method "verify_biguintn_from_bytes(byte[])uint256", method "verify_uintn_from_log(byte[])uint32", method "verify_biguintn_from_log(byte[])uint256", method "verify_ufixednxm_bytes(ufixed32x8)byte[]", method "verify_bigufixednxm_bytes(ufixed256x16)byte[]", method "verify_ufixednxm_from_bytes(byte[])ufixed32x8", method "verify_bigufixednxm_from_bytes(byte[])ufixed256x16", method "verify_ufixednxm_from_log(byte[])ufixed32x8", method "verify_bigufixednxm_from_log(byte[])ufixed256x16", method "verify_string_init(string)string", method "verify_string_add(string,string)string", method "verify_string_eq(string,string)bool", method "verify_string_bytes(string)byte[]", method "verify_string_from_bytes(byte[])string", method "verify_string_from_log(byte[])string", method "verify_bool_bytes(bool)byte[]", method "verify_bool_from_bytes(byte[])bool", method "verify_bool_from_log(byte[])bool", method "verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_uintn_uintn_eq_route@3 main_verify_biguintn_uintn_eq_route@4 main_verify_uintn_biguintn_eq_route@5 main_verify_biguintn_biguintn_eq_route@6 main_verify_uintn_uintn_ne_route@7 main_verify_biguintn_uintn_ne_route@8 main_verify_uintn_biguintn_ne_route@9 main_verify_biguintn_biguintn_ne_route@10 main_verify_uintn_uintn_lt_route@11 main_verify_biguintn_uintn_lt_route@12 main_verify_uintn_biguintn_lt_route@13 main_verify_biguintn_biguintn_lt_route@14 main_verify_uintn_uintn_le_route@15 main_verify_biguintn_uintn_le_route@16 main_verify_uintn_biguintn_le_route@17 main_verify_biguintn_biguintn_le_route@18 main_verify_uintn_uintn_gt_route@19 main_verify_biguintn_uintn_gt_route@20 main_verify_uintn_biguintn_gt_route@21 main_verify_biguintn_biguintn_gt_route@22 main_verify_uintn_uintn_ge_route@23 main_verify_biguintn_uintn_ge_route@24 main_verify_uintn_biguintn_ge_route@25 main_verify_biguintn_biguintn_ge_route@26 main_verify_uintn_init_route@27 main_verify_biguintn_init_route@28 main_verify_uintn_from_bytes_route@29 main_verify_biguintn_from_bytes_route@30 main_verify_uintn_from_log_route@31 main_verify_biguintn_from_log_route@32 main_verify_ufixednxm_bytes_route@33 main_verify_bigufixednxm_bytes_route@34 main_verify_ufixednxm_from_bytes_route@35 main_verify_bigufixednxm_from_bytes_route@36 main_verify_ufixednxm_from_log_route@37 main_verify_bigufixednxm_from_log_route@38 main_verify_string_init_route@39 main_verify_string_add_route@40 main_verify_string_eq_route@41 main_verify_string_bytes_route@42 main_verify_string_from_bytes_route@43 main_verify_string_from_log_route@44 main_verify_bool_bytes_route@45 main_verify_bool_from_bytes_route@46 main_verify_bool_from_log_route@47 main_verify_emit_route@48

main_after_if_else@55:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    intc_3 // 0
    return

main_verify_emit_route@48:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    txna ApplicationArgs 12
    txna ApplicationArgs 13
    txna ApplicationArgs 14
    extract 2 0
    txna ApplicationArgs 15
    dup
    intc_3 // 0
    extract_uint16
    dig 1
    pushint 2 // 2
    extract_uint16
    substring3
    extract 2 0
    txna ApplicationArgs 15
    dup
    pushint 2 // 2
    extract_uint16
    dig 1
    len
    substring3
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    callsub verify_emit
    intc_0 // 1
    return

main_verify_bool_from_log_route@47:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    callsub verify_bool_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_from_bytes_route@46:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_bytes_route@45:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_log_route@44:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    callsub verify_string_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_bytes_route@43:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_bytes_route@42:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    callsub verify_string_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_eq_route@41:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    callsub verify_string_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_add_route@40:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    callsub verify_string_add
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_init_route@39:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    callsub verify_string_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_log_route@38:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    callsub verify_bigufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_log_route@37:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    callsub verify_ufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_bytes_route@36:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_bytes_route@35:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_bytes_route@34:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_bytes_route@33:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_log_route@32:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    callsub verify_biguintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_log_route@31:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    callsub verify_uintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_bytes_route@30:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_bytes_route@29:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_init_route@28:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_biguintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_init_route@27:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_uintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ge_route@26:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ge_route@25:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ge_route@24:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ge_route@23:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_gt_route@22:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_gt_route@21:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_gt_route@20:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_gt_route@19:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_uintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_le_route@18:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_le_route@17:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_le_route@16:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_le_route@15:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    callsub verify_uintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_lt_route@14:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_lt_route@13:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_lt_route@12:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_lt_route@11:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_uintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ne_route@10:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ne_route@9:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ne_route@8:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ne_route@7:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_eq_route@6:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_eq_route@5:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_eq_route@4:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_eq_route@3:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    callsub verify_uintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@51:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@55
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7-8
    // @arc4.abimethod()
    // def verify_uintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:11
    // return arc4.UInt64(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13-14
    // @arc4.abimethod()
    // def verify_biguintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:17
    // return arc4.UInt512(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19-20
    // @arc4.abimethod()
    // def verify_uintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:23
    // return arc4.UInt64(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:29
    // return arc4.UInt512(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_uintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:35
    // return arc4.UInt64(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:41
    // return arc4.UInt512(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43-44
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:47
    // return arc4.UInt64(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49-50
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:53
    // return arc4.UInt512(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55-56
    // @arc4.abimethod()
    // def verify_uintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:59
    // return arc4.UInt64(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61-62
    // @arc4.abimethod()
    // def verify_biguintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:65
    // return arc4.UInt512(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_uintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:71
    // return arc4.UInt64(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73-74
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:77
    // return arc4.UInt512(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79-80
    // @arc4.abimethod()
    // def verify_uintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:83
    // return arc4.UInt64(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85-86
    // @arc4.abimethod()
    // def verify_biguintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:89
    // return arc4.UInt512(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_uintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:95
    // return arc4.UInt64(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97-98
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:101
    // return arc4.UInt512(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_uintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:107
    // return arc4.UInt64(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109-110
    // @arc4.abimethod()
    // def verify_biguintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:113
    // return arc4.UInt512(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115-116
    // @arc4.abimethod()
    // def verify_uintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:119
    // return arc4.UInt64(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:125
    // return arc4.UInt512(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127-128
    // @arc4.abimethod()
    // def verify_uintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:131
    // return arc4.UInt64(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133-134
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:137
    // return arc4.UInt512(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139-140
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:143
    // return arc4.UInt64(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:149
    // return arc4.UInt512(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_init(a: bytes) -> bytes:
verify_uintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_uintn_init(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:154
    // return arc4.UInt32(a_biguint)
    frame_dig -1
    len
    pushint 4 // 4
    <=
    assert // overflow
    pushint 4 // 4
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_init(a: bytes) -> bytes:
verify_biguintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_biguintn_init(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:159
    // return arc4.UInt256(a_biguint)
    frame_dig -1
    len
    pushint 32 // 32
    <=
    assert // overflow
    pushint 32 // 32
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_log(a: bytes) -> bytes:
verify_uintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169-170
    // @arc4.abimethod()
    // def verify_uintn_from_log(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:171
    // return arc4.UInt32.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_log(a: bytes) -> bytes:
verify_biguintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173-174
    // @arc4.abimethod()
    // def verify_biguintn_from_log(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:175
    // return arc4.UInt256.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_log(a: bytes) -> bytes:
verify_ufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201-204
    // @arc4.abimethod()
    // def verify_ufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:205
    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_log(a: bytes) -> bytes:
verify_bigufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207-210
    // @arc4.abimethod()
    // def verify_bigufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:211
    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_init(a: bytes) -> bytes:
verify_string_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213-214
    // @arc4.abimethod
    // def verify_string_init(self, a: String) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:215
    // result = arc4.String(String("Hello, ") + a)
    pushbytes "Hello, "
    frame_dig -1
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:216
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_add(a: bytes, b: bytes) -> bytes:
verify_string_add:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218-219
    // @arc4.abimethod
    // def verify_string_add(self, a: arc4.String, b: arc4.String) -> arc4.String:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:220
    // result = a + b
    frame_dig -1
    extract 2 0
    frame_dig -2
    swap
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:221
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_eq(a: bytes, b: bytes) -> uint64:
verify_string_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223-224
    // @arc4.abimethod()
    // def verify_string_eq(self, a: arc4.String, b: arc4.String) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:225
    // return a == b
    frame_dig -2
    frame_dig -1
    ==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_bytes(a: bytes) -> bytes:
verify_string_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227-228
    // @arc4.abimethod()
    // def verify_string_bytes(self, a: String) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:229
    // result = arc4.String(a)
    frame_dig -1
    len
    itob
    extract 6 2
    frame_dig -1
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:230
    // return result.bytes
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_log(a: bytes) -> bytes:
verify_string_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236-237
    // @arc4.abimethod()
    // def verify_string_from_log(self, a: Bytes) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:238
    // return arc4.String.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_log(a: bytes) -> bytes:
verify_bool_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248-249
    // @arc4.abimethod()
    // def verify_bool_from_log(self, a: Bytes) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:250
    // return arc4.Bool.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_emit(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes, f: bytes, g: bytes, h: bytes, m: bytes, n: bytes, o: bytes, p: bytes, q: bytes, r: bytes, s: bytes, t: bytes) -> void:
verify_emit:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252-271
    // @arc4.abimethod()
    // def verify_emit(  # noqa: PLR0913
    //     self,
    //     a: arc4.String,
    //     b: arc4.UInt512,
    //     c: arc4.UInt64,
    //     d: arc4.DynamicBytes,
    //     e: arc4.UInt64,
    //     f: arc4.Bool,
    //     g: arc4.DynamicBytes,
    //     h: arc4.String,
    //     m: arc4.UIntN[typing.Literal[64]],
    //     n: arc4.BigUIntN[typing.Literal[256]],
    //     o: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
    //     p: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
    //     q: arc4.Bool,
    //     r: Bytes,
    //     s: Bytes,
    //     t: Bytes,
    // ) -> None:
    proto 16 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:276
    // arc4.emit(SwappedArc4(m, n, o, p, q, arc4_r, arc4_s, arc4_t))
    frame_dig -8
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    pushbytes 0x0054
    concat
    frame_dig -2
    len
    pushint 84 // 84
    dig 1
    +
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0x66bb0333 // method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:277-295
    // arc4.emit(
    //     "Swapped",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    frame_dig -16
    len
    pushint 173 // 173
    +
    pushbytes 0x00ad
    frame_dig -15
    concat
    frame_dig -14
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -13
    len
    uncover 2
    +
    swap
    frame_dig -12
    concat
    frame_dig -11
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -10
    len
    uncover 2
    +
    dup
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -9
    len
    uncover 2
    +
    swap
    frame_dig -8
    concat
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    dig 1
    itob
    extract 6 2
    concat
    swap
    uncover 2
    +
    itob
    extract 6 2
    concat
    frame_dig -16
    concat
    frame_dig -13
    concat
    frame_dig -10
    concat
    frame_dig -9
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0xec3319bb // method "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    dup
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:296-314
    // arc4.emit(
    //     "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    log
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc56.json b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc56.json
index 1cb9261d..d07c2891 100644
--- a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc56.json
+++ b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc56.json
@@ -1282,65 +1282,65 @@
                         441,
                         463,
                         482,
-                        503,
-                        525,
-                        544,
-                        574,
-                        601,
-                        623,
-                        645,
-                        667,
-                        689,
-                        708,
-                        727,
-                        748,
-                        769,
-                        791,
-                        813,
-                        832,
-                        851,
-                        873,
-                        895,
-                        928,
-                        961,
-                        994,
-                        1027,
-                        1060,
-                        1093,
-                        1126,
-                        1159,
-                        1192,
-                        1225,
-                        1258,
-                        1291,
-                        1324,
-                        1357,
-                        1390,
-                        1423,
-                        1456,
-                        1489,
-                        1522,
-                        1555,
-                        1588,
-                        1621,
-                        1654
+                        506,
+                        528,
+                        547,
+                        577,
+                        604,
+                        626,
+                        648,
+                        670,
+                        692,
+                        711,
+                        730,
+                        754,
+                        778,
+                        800,
+                        822,
+                        841,
+                        860,
+                        882,
+                        904,
+                        937,
+                        970,
+                        1003,
+                        1036,
+                        1069,
+                        1102,
+                        1135,
+                        1168,
+                        1201,
+                        1234,
+                        1267,
+                        1300,
+                        1333,
+                        1366,
+                        1399,
+                        1432,
+                        1465,
+                        1498,
+                        1531,
+                        1564,
+                        1597,
+                        1630,
+                        1663
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        2416,
-                        2433,
-                        2450,
-                        2467,
-                        2554,
-                        2571
+                        2425,
+                        2442,
+                        2459,
+                        2476,
+                        2564,
+                        2581
                     ],
                     "errorMessage": "application log value is not the result of an ABI return"
                 },
                 {
                     "pc": [
-                        1692
+                        1701
                     ],
                     "errorMessage": "can only call when creating"
                 },
@@ -1350,103 +1350,109 @@
                         444,
                         466,
                         485,
-                        506,
-                        528,
-                        547,
-                        577,
-                        604,
-                        626,
-                        648,
-                        670,
-                        692,
-                        711,
-                        730,
-                        751,
-                        772,
-                        794,
-                        816,
-                        835,
-                        854,
-                        876,
-                        898,
-                        931,
-                        964,
-                        997,
-                        1030,
-                        1063,
-                        1096,
-                        1129,
-                        1162,
-                        1195,
-                        1228,
-                        1261,
-                        1294,
-                        1327,
-                        1360,
-                        1393,
-                        1426,
-                        1459,
-                        1492,
-                        1525,
-                        1558,
-                        1591,
-                        1624,
-                        1657
+                        509,
+                        531,
+                        550,
+                        580,
+                        607,
+                        629,
+                        651,
+                        673,
+                        695,
+                        714,
+                        733,
+                        757,
+                        781,
+                        803,
+                        825,
+                        844,
+                        863,
+                        885,
+                        907,
+                        940,
+                        973,
+                        1006,
+                        1039,
+                        1072,
+                        1105,
+                        1138,
+                        1171,
+                        1204,
+                        1237,
+                        1270,
+                        1303,
+                        1336,
+                        1369,
+                        1402,
+                        1435,
+                        1468,
+                        1501,
+                        1534,
+                        1567,
+                        1600,
+                        1633,
+                        1666
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        1703,
-                        1716,
-                        1732,
-                        1743,
-                        1759,
-                        1770,
-                        1786,
-                        1799,
-                        1815,
-                        1828,
-                        1844,
-                        1855,
-                        1871,
-                        1882,
-                        1898,
-                        1911,
-                        1927,
-                        1940,
-                        1956,
-                        1967,
-                        1983,
-                        1994,
-                        2010,
-                        2023,
-                        2039,
-                        2052,
-                        2068,
-                        2079,
-                        2095,
-                        2106,
-                        2122,
-                        2135,
-                        2151,
-                        2164,
-                        2180,
-                        2191,
-                        2207,
-                        2218,
-                        2234,
-                        2247,
-                        2263,
-                        2276,
-                        2292,
-                        2303,
-                        2319,
-                        2330,
-                        2346,
-                        2359,
-                        2376,
-                        2393
+                        2513
+                    ],
+                    "errorMessage": "max array length exceeded"
+                },
+                {
+                    "pc": [
+                        1712,
+                        1725,
+                        1741,
+                        1752,
+                        1768,
+                        1779,
+                        1795,
+                        1808,
+                        1824,
+                        1837,
+                        1853,
+                        1864,
+                        1880,
+                        1891,
+                        1907,
+                        1920,
+                        1936,
+                        1949,
+                        1965,
+                        1976,
+                        1992,
+                        2003,
+                        2019,
+                        2032,
+                        2048,
+                        2061,
+                        2077,
+                        2088,
+                        2104,
+                        2115,
+                        2131,
+                        2144,
+                        2160,
+                        2173,
+                        2189,
+                        2200,
+                        2216,
+                        2227,
+                        2243,
+                        2256,
+                        2272,
+                        2285,
+                        2301,
+                        2312,
+                        2328,
+                        2339,
+                        2355,
+                        2368,
+                        2385,
+                        2402
                     ],
                     "errorMessage": "overflow"
                 }
@@ -1459,19 +1465,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 64 0
    bytecblock 0x151f7c75 0x00
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@51
    pushbytess 0x96f14116 0xed666096 0x2ca0352b 0x85907d40 0x2cbec45b 0x07666fd9 0x370babd3 0x2b6b3ef0 0x339da97c 0x7898ed97 0x1f130cec 0xc748664e 0x7a460cb1 0xdcab1f01 0x97d9064d 0xce06c2a0 0xdcdbcee0 0x77a4b68d 0x4f540626 0x095aed41 0xe3b7e918 0x55337008 0x9bb1cd66 0x81484d9d 0x9a03df10 0xd3f0e44b 0x982db233 0xaffbdf0e 0x288af76e 0x8bd84a04 0x0f1574fe 0xb2cb13be 0xd059eea7 0x4cc4c157 0x3d17ac6e 0xf7f3d5fc 0xf8c8f8d5 0x43f7162a 0x42e09075 0xd956f575 0x6c0160df 0xa890150b 0x0b2f4c3f 0x9db9d327 0xe4d950a1 0xb605e80c // method "verify_uintn_uintn_eq(byte[],byte[])bool", method "verify_biguintn_uintn_eq(byte[],byte[])bool", method "verify_uintn_biguintn_eq(byte[],byte[])bool", method "verify_biguintn_biguintn_eq(byte[],byte[])bool", method "verify_uintn_uintn_ne(byte[],byte[])bool", method "verify_biguintn_uintn_ne(byte[],byte[])bool", method "verify_uintn_biguintn_ne(byte[],byte[])bool", method "verify_biguintn_biguintn_ne(byte[],byte[])bool", method "verify_uintn_uintn_lt(byte[],byte[])bool", method "verify_biguintn_uintn_lt(byte[],byte[])bool", method "verify_uintn_biguintn_lt(byte[],byte[])bool", method "verify_biguintn_biguintn_lt(byte[],byte[])bool", method "verify_uintn_uintn_le(byte[],byte[])bool", method "verify_biguintn_uintn_le(byte[],byte[])bool", method "verify_uintn_biguintn_le(byte[],byte[])bool", method "verify_biguintn_biguintn_le(byte[],byte[])bool", method "verify_uintn_uintn_gt(byte[],byte[])bool", method "verify_biguintn_uintn_gt(byte[],byte[])bool", method "verify_uintn_biguintn_gt(byte[],byte[])bool", method "verify_biguintn_biguintn_gt(byte[],byte[])bool", method "verify_uintn_uintn_ge(byte[],byte[])bool", method "verify_biguintn_uintn_ge(byte[],byte[])bool", method "verify_uintn_biguintn_ge(byte[],byte[])bool", method "verify_biguintn_biguintn_ge(byte[],byte[])bool", method "verify_uintn_init(byte[])uint32", method "verify_biguintn_init(byte[])uint256", method "verify_uintn_from_bytes(byte[])uint32", method "verify_biguintn_from_bytes(byte[])uint256", method "verify_uintn_from_log(byte[])uint32", method "verify_biguintn_from_log(byte[])uint256", method "verify_ufixednxm_bytes(ufixed32x8)byte[]", method "verify_bigufixednxm_bytes(ufixed256x16)byte[]", method "verify_ufixednxm_from_bytes(byte[])ufixed32x8", method "verify_bigufixednxm_from_bytes(byte[])ufixed256x16", method "verify_ufixednxm_from_log(byte[])ufixed32x8", method "verify_bigufixednxm_from_log(byte[])ufixed256x16", method "verify_string_init(string)string", method "verify_string_add(string,string)string", method "verify_string_eq(string,string)bool", method "verify_string_bytes(string)byte[]", method "verify_string_from_bytes(byte[])string", method "verify_string_from_log(byte[])string", method "verify_bool_bytes(bool)byte[]", method "verify_bool_from_bytes(byte[])bool", method "verify_bool_from_log(byte[])bool", method "verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_uintn_uintn_eq_route@3 main_verify_biguintn_uintn_eq_route@4 main_verify_uintn_biguintn_eq_route@5 main_verify_biguintn_biguintn_eq_route@6 main_verify_uintn_uintn_ne_route@7 main_verify_biguintn_uintn_ne_route@8 main_verify_uintn_biguintn_ne_route@9 main_verify_biguintn_biguintn_ne_route@10 main_verify_uintn_uintn_lt_route@11 main_verify_biguintn_uintn_lt_route@12 main_verify_uintn_biguintn_lt_route@13 main_verify_biguintn_biguintn_lt_route@14 main_verify_uintn_uintn_le_route@15 main_verify_biguintn_uintn_le_route@16 main_verify_uintn_biguintn_le_route@17 main_verify_biguintn_biguintn_le_route@18 main_verify_uintn_uintn_gt_route@19 main_verify_biguintn_uintn_gt_route@20 main_verify_uintn_biguintn_gt_route@21 main_verify_biguintn_biguintn_gt_route@22 main_verify_uintn_uintn_ge_route@23 main_verify_biguintn_uintn_ge_route@24 main_verify_uintn_biguintn_ge_route@25 main_verify_biguintn_biguintn_ge_route@26 main_verify_uintn_init_route@27 main_verify_biguintn_init_route@28 main_verify_uintn_from_bytes_route@29 main_verify_biguintn_from_bytes_route@30 main_verify_uintn_from_log_route@31 main_verify_biguintn_from_log_route@32 main_verify_ufixednxm_bytes_route@33 main_verify_bigufixednxm_bytes_route@34 main_verify_ufixednxm_from_bytes_route@35 main_verify_bigufixednxm_from_bytes_route@36 main_verify_ufixednxm_from_log_route@37 main_verify_bigufixednxm_from_log_route@38 main_verify_string_init_route@39 main_verify_string_add_route@40 main_verify_string_eq_route@41 main_verify_string_bytes_route@42 main_verify_string_from_bytes_route@43 main_verify_string_from_log_route@44 main_verify_bool_bytes_route@45 main_verify_bool_from_bytes_route@46 main_verify_bool_from_log_route@47 main_verify_emit_route@48

main_after_if_else@55:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    intc_3 // 0
    return

main_verify_emit_route@48:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    txna ApplicationArgs 12
    txna ApplicationArgs 13
    txna ApplicationArgs 14
    extract 2 0
    txna ApplicationArgs 15
    dup
    intc_3 // 0
    extract_uint16
    dig 1
    pushint 2 // 2
    extract_uint16
    substring3
    extract 2 0
    txna ApplicationArgs 15
    dup
    pushint 2 // 2
    extract_uint16
    dig 1
    len
    substring3
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    callsub verify_emit
    intc_0 // 1
    return

main_verify_bool_from_log_route@47:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    callsub verify_bool_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_from_bytes_route@46:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_bytes_route@45:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    pushbytes 0x0001
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_log_route@44:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    callsub verify_string_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_bytes_route@43:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_bytes_route@42:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    callsub verify_string_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_eq_route@41:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    callsub verify_string_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_add_route@40:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    callsub verify_string_add
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_init_route@39:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    callsub verify_string_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_log_route@38:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    callsub verify_bigufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_log_route@37:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    callsub verify_ufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_bytes_route@36:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_bytes_route@35:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_bytes_route@34:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    pushbytes 0x0020
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_bytes_route@33:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    pushbytes 0x0004
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_log_route@32:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    callsub verify_biguintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_log_route@31:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    callsub verify_uintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_bytes_route@30:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_bytes_route@29:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_init_route@28:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_biguintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_init_route@27:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_uintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ge_route@26:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ge_route@25:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ge_route@24:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ge_route@23:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_gt_route@22:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_gt_route@21:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_gt_route@20:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_gt_route@19:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_uintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_le_route@18:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_le_route@17:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_le_route@16:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_le_route@15:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    callsub verify_uintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_lt_route@14:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_lt_route@13:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_lt_route@12:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_lt_route@11:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_uintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ne_route@10:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ne_route@9:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ne_route@8:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ne_route@7:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_eq_route@6:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_eq_route@5:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_eq_route@4:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_eq_route@3:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    callsub verify_uintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@51:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@55
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7-8
    // @arc4.abimethod()
    // def verify_uintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:11
    // return arc4.UInt64(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13-14
    // @arc4.abimethod()
    // def verify_biguintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:17
    // return arc4.UInt512(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19-20
    // @arc4.abimethod()
    // def verify_uintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:23
    // return arc4.UInt64(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:29
    // return arc4.UInt512(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_uintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:35
    // return arc4.UInt64(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:41
    // return arc4.UInt512(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43-44
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:47
    // return arc4.UInt64(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49-50
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:53
    // return arc4.UInt512(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55-56
    // @arc4.abimethod()
    // def verify_uintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:59
    // return arc4.UInt64(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61-62
    // @arc4.abimethod()
    // def verify_biguintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:65
    // return arc4.UInt512(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_uintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:71
    // return arc4.UInt64(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73-74
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:77
    // return arc4.UInt512(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79-80
    // @arc4.abimethod()
    // def verify_uintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:83
    // return arc4.UInt64(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85-86
    // @arc4.abimethod()
    // def verify_biguintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:89
    // return arc4.UInt512(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_uintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:95
    // return arc4.UInt64(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97-98
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:101
    // return arc4.UInt512(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_uintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:107
    // return arc4.UInt64(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109-110
    // @arc4.abimethod()
    // def verify_biguintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:113
    // return arc4.UInt512(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115-116
    // @arc4.abimethod()
    // def verify_uintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:119
    // return arc4.UInt64(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:125
    // return arc4.UInt512(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127-128
    // @arc4.abimethod()
    // def verify_uintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:131
    // return arc4.UInt64(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133-134
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:137
    // return arc4.UInt512(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139-140
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:143
    // return arc4.UInt64(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:149
    // return arc4.UInt512(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_init(a: bytes) -> bytes:
verify_uintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_uintn_init(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:154
    // return arc4.UInt32(a_biguint)
    frame_dig -1
    len
    pushint 4 // 4
    <=
    assert // overflow
    pushint 4 // 4
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_init(a: bytes) -> bytes:
verify_biguintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_biguintn_init(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:159
    // return arc4.UInt256(a_biguint)
    frame_dig -1
    len
    pushint 32 // 32
    <=
    assert // overflow
    pushint 32 // 32
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_log(a: bytes) -> bytes:
verify_uintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169-170
    // @arc4.abimethod()
    // def verify_uintn_from_log(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:171
    // return arc4.UInt32.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_log(a: bytes) -> bytes:
verify_biguintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173-174
    // @arc4.abimethod()
    // def verify_biguintn_from_log(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:175
    // return arc4.UInt256.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_log(a: bytes) -> bytes:
verify_ufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201-204
    // @arc4.abimethod()
    // def verify_ufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:205
    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_log(a: bytes) -> bytes:
verify_bigufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207-210
    // @arc4.abimethod()
    // def verify_bigufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:211
    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_init(a: bytes) -> bytes:
verify_string_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213-214
    // @arc4.abimethod
    // def verify_string_init(self, a: String) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:215
    // result = arc4.String(String("Hello, ") + a)
    pushbytes "Hello, "
    frame_dig -1
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:216
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_add(a: bytes, b: bytes) -> bytes:
verify_string_add:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218-219
    // @arc4.abimethod
    // def verify_string_add(self, a: arc4.String, b: arc4.String) -> arc4.String:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:220
    // result = a + b
    frame_dig -2
    extract 2 0
    frame_dig -1
    extract 2 0
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:221
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_eq(a: bytes, b: bytes) -> uint64:
verify_string_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223-224
    // @arc4.abimethod()
    // def verify_string_eq(self, a: arc4.String, b: arc4.String) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:225
    // return a == b
    frame_dig -2
    frame_dig -1
    ==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_bytes(a: bytes) -> bytes:
verify_string_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227-228
    // @arc4.abimethod()
    // def verify_string_bytes(self, a: String) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:229
    // result = arc4.String(a)
    frame_dig -1
    len
    itob
    extract 6 2
    frame_dig -1
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:230
    // return result.bytes
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_log(a: bytes) -> bytes:
verify_string_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236-237
    // @arc4.abimethod()
    // def verify_string_from_log(self, a: Bytes) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:238
    // return arc4.String.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_log(a: bytes) -> bytes:
verify_bool_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248-249
    // @arc4.abimethod()
    // def verify_bool_from_log(self, a: Bytes) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:250
    // return arc4.Bool.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_emit(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes, f: bytes, g: bytes, h: bytes, m: bytes, n: bytes, o: bytes, p: bytes, q: bytes, r: bytes, s: bytes, t: bytes) -> void:
verify_emit:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252-271
    // @arc4.abimethod()
    // def verify_emit(  # noqa: PLR0913
    //     self,
    //     a: arc4.String,
    //     b: arc4.UInt512,
    //     c: arc4.UInt64,
    //     d: arc4.DynamicBytes,
    //     e: arc4.UInt64,
    //     f: arc4.Bool,
    //     g: arc4.DynamicBytes,
    //     h: arc4.String,
    //     m: arc4.UIntN[typing.Literal[64]],
    //     n: arc4.BigUIntN[typing.Literal[256]],
    //     o: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
    //     p: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
    //     q: arc4.Bool,
    //     r: Bytes,
    //     s: Bytes,
    //     t: Bytes,
    // ) -> None:
    proto 16 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:276
    // arc4.emit(SwappedArc4(m, n, o, p, q, arc4_r, arc4_s, arc4_t))
    frame_dig -8
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    pushbytes 0x0054
    concat
    frame_dig -2
    len
    pushint 84 // 84
    dig 1
    +
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0x66bb0333 // method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:277-295
    // arc4.emit(
    //     "Swapped",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    frame_dig -16
    len
    pushint 173 // 173
    +
    pushbytes 0x00ad
    frame_dig -15
    concat
    frame_dig -14
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -13
    len
    uncover 2
    +
    swap
    frame_dig -12
    concat
    frame_dig -11
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -10
    len
    uncover 2
    +
    dup
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -9
    len
    uncover 2
    +
    swap
    frame_dig -8
    concat
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    dig 1
    itob
    extract 6 2
    concat
    swap
    uncover 2
    +
    itob
    extract 6 2
    concat
    frame_dig -16
    concat
    frame_dig -13
    concat
    frame_dig -10
    concat
    frame_dig -9
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0xec3319bb // method "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    dup
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:296-314
    // arc4.emit(
    //     "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    log
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 64 0
    bytecblock 0x151f7c75 0x00
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@51
    pushbytess 0x96f14116 0xed666096 0x2ca0352b 0x85907d40 0x2cbec45b 0x07666fd9 0x370babd3 0x2b6b3ef0 0x339da97c 0x7898ed97 0x1f130cec 0xc748664e 0x7a460cb1 0xdcab1f01 0x97d9064d 0xce06c2a0 0xdcdbcee0 0x77a4b68d 0x4f540626 0x095aed41 0xe3b7e918 0x55337008 0x9bb1cd66 0x81484d9d 0x9a03df10 0xd3f0e44b 0x982db233 0xaffbdf0e 0x288af76e 0x8bd84a04 0x0f1574fe 0xb2cb13be 0xd059eea7 0x4cc4c157 0x3d17ac6e 0xf7f3d5fc 0xf8c8f8d5 0x43f7162a 0x42e09075 0xd956f575 0x6c0160df 0xa890150b 0x0b2f4c3f 0x9db9d327 0xe4d950a1 0xb605e80c // method "verify_uintn_uintn_eq(byte[],byte[])bool", method "verify_biguintn_uintn_eq(byte[],byte[])bool", method "verify_uintn_biguintn_eq(byte[],byte[])bool", method "verify_biguintn_biguintn_eq(byte[],byte[])bool", method "verify_uintn_uintn_ne(byte[],byte[])bool", method "verify_biguintn_uintn_ne(byte[],byte[])bool", method "verify_uintn_biguintn_ne(byte[],byte[])bool", method "verify_biguintn_biguintn_ne(byte[],byte[])bool", method "verify_uintn_uintn_lt(byte[],byte[])bool", method "verify_biguintn_uintn_lt(byte[],byte[])bool", method "verify_uintn_biguintn_lt(byte[],byte[])bool", method "verify_biguintn_biguintn_lt(byte[],byte[])bool", method "verify_uintn_uintn_le(byte[],byte[])bool", method "verify_biguintn_uintn_le(byte[],byte[])bool", method "verify_uintn_biguintn_le(byte[],byte[])bool", method "verify_biguintn_biguintn_le(byte[],byte[])bool", method "verify_uintn_uintn_gt(byte[],byte[])bool", method "verify_biguintn_uintn_gt(byte[],byte[])bool", method "verify_uintn_biguintn_gt(byte[],byte[])bool", method "verify_biguintn_biguintn_gt(byte[],byte[])bool", method "verify_uintn_uintn_ge(byte[],byte[])bool", method "verify_biguintn_uintn_ge(byte[],byte[])bool", method "verify_uintn_biguintn_ge(byte[],byte[])bool", method "verify_biguintn_biguintn_ge(byte[],byte[])bool", method "verify_uintn_init(byte[])uint32", method "verify_biguintn_init(byte[])uint256", method "verify_uintn_from_bytes(byte[])uint32", method "verify_biguintn_from_bytes(byte[])uint256", method "verify_uintn_from_log(byte[])uint32", method "verify_biguintn_from_log(byte[])uint256", method "verify_ufixednxm_bytes(ufixed32x8)byte[]", method "verify_bigufixednxm_bytes(ufixed256x16)byte[]", method "verify_ufixednxm_from_bytes(byte[])ufixed32x8", method "verify_bigufixednxm_from_bytes(byte[])ufixed256x16", method "verify_ufixednxm_from_log(byte[])ufixed32x8", method "verify_bigufixednxm_from_log(byte[])ufixed256x16", method "verify_string_init(string)string", method "verify_string_add(string,string)string", method "verify_string_eq(string,string)bool", method "verify_string_bytes(string)byte[]", method "verify_string_from_bytes(byte[])string", method "verify_string_from_log(byte[])string", method "verify_bool_bytes(bool)byte[]", method "verify_bool_from_bytes(byte[])bool", method "verify_bool_from_log(byte[])bool", method "verify_emit(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_uintn_uintn_eq_route@3 main_verify_biguintn_uintn_eq_route@4 main_verify_uintn_biguintn_eq_route@5 main_verify_biguintn_biguintn_eq_route@6 main_verify_uintn_uintn_ne_route@7 main_verify_biguintn_uintn_ne_route@8 main_verify_uintn_biguintn_ne_route@9 main_verify_biguintn_biguintn_ne_route@10 main_verify_uintn_uintn_lt_route@11 main_verify_biguintn_uintn_lt_route@12 main_verify_uintn_biguintn_lt_route@13 main_verify_biguintn_biguintn_lt_route@14 main_verify_uintn_uintn_le_route@15 main_verify_biguintn_uintn_le_route@16 main_verify_uintn_biguintn_le_route@17 main_verify_biguintn_biguintn_le_route@18 main_verify_uintn_uintn_gt_route@19 main_verify_biguintn_uintn_gt_route@20 main_verify_uintn_biguintn_gt_route@21 main_verify_biguintn_biguintn_gt_route@22 main_verify_uintn_uintn_ge_route@23 main_verify_biguintn_uintn_ge_route@24 main_verify_uintn_biguintn_ge_route@25 main_verify_biguintn_biguintn_ge_route@26 main_verify_uintn_init_route@27 main_verify_biguintn_init_route@28 main_verify_uintn_from_bytes_route@29 main_verify_biguintn_from_bytes_route@30 main_verify_uintn_from_log_route@31 main_verify_biguintn_from_log_route@32 main_verify_ufixednxm_bytes_route@33 main_verify_bigufixednxm_bytes_route@34 main_verify_ufixednxm_from_bytes_route@35 main_verify_bigufixednxm_from_bytes_route@36 main_verify_ufixednxm_from_log_route@37 main_verify_bigufixednxm_from_log_route@38 main_verify_string_init_route@39 main_verify_string_add_route@40 main_verify_string_eq_route@41 main_verify_string_bytes_route@42 main_verify_string_from_bytes_route@43 main_verify_string_from_log_route@44 main_verify_bool_bytes_route@45 main_verify_bool_from_bytes_route@46 main_verify_bool_from_log_route@47 main_verify_emit_route@48

main_after_if_else@55:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    intc_3 // 0
    return

main_verify_emit_route@48:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    txna ApplicationArgs 12
    txna ApplicationArgs 13
    txna ApplicationArgs 14
    extract 2 0
    txna ApplicationArgs 15
    dup
    intc_3 // 0
    extract_uint16
    dig 1
    pushint 2 // 2
    extract_uint16
    substring3
    extract 2 0
    txna ApplicationArgs 15
    dup
    pushint 2 // 2
    extract_uint16
    dig 1
    len
    substring3
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    callsub verify_emit
    intc_0 // 1
    return

main_verify_bool_from_log_route@47:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    callsub verify_bool_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_from_bytes_route@46:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bool_bytes_route@45:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_log_route@44:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    callsub verify_string_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_from_bytes_route@43:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_bytes_route@42:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    callsub verify_string_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_eq_route@41:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    callsub verify_string_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_add_route@40:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    callsub verify_string_add
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_init_route@39:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    callsub verify_string_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_log_route@38:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    callsub verify_bigufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_log_route@37:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    callsub verify_ufixednxm_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_from_bytes_route@36:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_from_bytes_route@35:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bigufixednxm_bytes_route@34:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_ufixednxm_bytes_route@33:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_log_route@32:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    callsub verify_biguintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_log_route@31:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    callsub verify_uintn_from_log
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_from_bytes_route@30:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_from_bytes_route@29:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_init_route@28:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_biguintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_init_route@27:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_uintn_init
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ge_route@26:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ge_route@25:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ge_route@24:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ge_route@23:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ge
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_gt_route@22:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_gt_route@21:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_gt_route@20:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_gt_route@19:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_uintn_uintn_gt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_le_route@18:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_le_route@17:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_le_route@16:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_le_route@15:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    callsub verify_uintn_uintn_le
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_lt_route@14:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_lt_route@13:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_lt_route@12:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_lt_route@11:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_uintn_uintn_lt
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_ne_route@10:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_ne_route@9:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_ne_route@8:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_ne_route@7:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_uintn_uintn_ne
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_biguintn_eq_route@6:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_biguintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_biguintn_eq_route@5:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    callsub verify_uintn_biguintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguintn_uintn_eq_route@4:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    callsub verify_biguintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uintn_uintn_eq_route@3:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    callsub verify_uintn_uintn_eq
    bytec_1 // 0x00
    intc_3 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@51:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@55
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7-8
    // @arc4.abimethod()
    // def verify_uintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:11
    // return arc4.UInt64(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13-14
    // @arc4.abimethod()
    // def verify_biguintn_uintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:17
    // return arc4.UInt512(a_biguint) == arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19-20
    // @arc4.abimethod()
    // def verify_uintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:23
    // return arc4.UInt64(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_eq(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:29
    // return arc4.UInt512(a_biguint) == arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_uintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:35
    // return arc4.UInt64(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:41
    // return arc4.UInt512(a_biguint) != arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43-44
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:47
    // return arc4.UInt64(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ne(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ne:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49-50
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:53
    // return arc4.UInt512(a_biguint) != arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b!=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55-56
    // @arc4.abimethod()
    // def verify_uintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:59
    // return arc4.UInt64(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61-62
    // @arc4.abimethod()
    // def verify_biguintn_uintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:65
    // return arc4.UInt512(a_biguint) < arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_uintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:71
    // return arc4.UInt64(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_lt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_lt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73-74
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:77
    // return arc4.UInt512(a_biguint) < arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79-80
    // @arc4.abimethod()
    // def verify_uintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:83
    // return arc4.UInt64(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85-86
    // @arc4.abimethod()
    // def verify_biguintn_uintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:89
    // return arc4.UInt512(a_biguint) <= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_uintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:95
    // return arc4.UInt64(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_le(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_le:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97-98
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:101
    // return arc4.UInt512(a_biguint) <= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b<=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_uintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:107
    // return arc4.UInt64(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109-110
    // @arc4.abimethod()
    // def verify_biguintn_uintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:113
    // return arc4.UInt512(a_biguint) > arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115-116
    // @arc4.abimethod()
    // def verify_uintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:119
    // return arc4.UInt64(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_gt(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_gt:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:125
    // return arc4.UInt512(a_biguint) > arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127-128
    // @arc4.abimethod()
    // def verify_uintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:131
    // return arc4.UInt64(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_uintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_uintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133-134
    // @arc4.abimethod()
    // def verify_biguintn_uintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:137
    // return arc4.UInt512(a_biguint) >= arc4.UInt64(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_uintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139-140
    // @arc4.abimethod()
    // def verify_uintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:143
    // return arc4.UInt64(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_1 // 8
    <=
    assert // overflow
    intc_1 // 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -1
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_biguintn_ge(a: bytes, b: bytes) -> uint64:
verify_biguintn_biguintn_ge:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_biguintn_biguintn_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:149
    // return arc4.UInt512(a_biguint) >= arc4.UInt512(b_biguint)
    frame_dig -2
    len
    intc_2 // 64
    <=
    assert // overflow
    intc_2 // 64
    bzero
    frame_dig -2
    dig 1
    b|
    frame_dig -1
    len
    intc_2 // 64
    <=
    assert // overflow
    frame_dig -1
    uncover 2
    b|
    b>=
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_init(a: bytes) -> bytes:
verify_uintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_uintn_init(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:154
    // return arc4.UInt32(a_biguint)
    frame_dig -1
    len
    pushint 4 // 4
    <=
    assert // overflow
    pushint 4 // 4
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_init(a: bytes) -> bytes:
verify_biguintn_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_biguintn_init(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:159
    // return arc4.UInt256(a_biguint)
    frame_dig -1
    len
    pushint 32 // 32
    <=
    assert // overflow
    pushint 32 // 32
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_log(a: bytes) -> bytes:
verify_uintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169-170
    // @arc4.abimethod()
    // def verify_uintn_from_log(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:171
    // return arc4.UInt32.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_log(a: bytes) -> bytes:
verify_biguintn_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173-174
    // @arc4.abimethod()
    // def verify_biguintn_from_log(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:175
    // return arc4.UInt256.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_log(a: bytes) -> bytes:
verify_ufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201-204
    // @arc4.abimethod()
    // def verify_ufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:205
    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_log(a: bytes) -> bytes:
verify_bigufixednxm_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207-210
    // @arc4.abimethod()
    // def verify_bigufixednxm_from_log(
    //     self, a: Bytes
    // ) -> arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:211
    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_init(a: bytes) -> bytes:
verify_string_init:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213-214
    // @arc4.abimethod
    // def verify_string_init(self, a: String) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:215
    // result = arc4.String(String("Hello, ") + a)
    pushbytes "Hello, "
    frame_dig -1
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:216
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_add(a: bytes, b: bytes) -> bytes:
verify_string_add:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218-219
    // @arc4.abimethod
    // def verify_string_add(self, a: arc4.String, b: arc4.String) -> arc4.String:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:220
    // result = a + b
    frame_dig -1
    extract 2 0
    frame_dig -2
    swap
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:221
    // return result
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_eq(a: bytes, b: bytes) -> uint64:
verify_string_eq:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223-224
    // @arc4.abimethod()
    // def verify_string_eq(self, a: arc4.String, b: arc4.String) -> bool:
    proto 2 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:225
    // return a == b
    frame_dig -2
    frame_dig -1
    ==
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_bytes(a: bytes) -> bytes:
verify_string_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227-228
    // @arc4.abimethod()
    // def verify_string_bytes(self, a: String) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:229
    // result = arc4.String(a)
    frame_dig -1
    len
    itob
    extract 6 2
    frame_dig -1
    concat
    // tests/artifacts/Arc4PrimitiveOps/contract.py:230
    // return result.bytes
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_log(a: bytes) -> bytes:
verify_string_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236-237
    // @arc4.abimethod()
    // def verify_string_from_log(self, a: Bytes) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:238
    // return arc4.String.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_log(a: bytes) -> bytes:
verify_bool_from_log:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248-249
    // @arc4.abimethod()
    // def verify_bool_from_log(self, a: Bytes) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:250
    // return arc4.Bool.from_log(a)
    frame_dig -1
    extract 4 0
    frame_dig -1
    extract 0 4
    bytec_0 // 0x151f7c75
    ==
    assert // application log value is not the result of an ABI return
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_emit(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes, f: bytes, g: bytes, h: bytes, m: bytes, n: bytes, o: bytes, p: bytes, q: bytes, r: bytes, s: bytes, t: bytes) -> void:
verify_emit:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252-271
    // @arc4.abimethod()
    // def verify_emit(  # noqa: PLR0913
    //     self,
    //     a: arc4.String,
    //     b: arc4.UInt512,
    //     c: arc4.UInt64,
    //     d: arc4.DynamicBytes,
    //     e: arc4.UInt64,
    //     f: arc4.Bool,
    //     g: arc4.DynamicBytes,
    //     h: arc4.String,
    //     m: arc4.UIntN[typing.Literal[64]],
    //     n: arc4.BigUIntN[typing.Literal[256]],
    //     o: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
    //     p: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
    //     q: arc4.Bool,
    //     r: Bytes,
    //     s: Bytes,
    //     t: Bytes,
    // ) -> None:
    proto 16 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:276
    // arc4.emit(SwappedArc4(m, n, o, p, q, arc4_r, arc4_s, arc4_t))
    frame_dig -8
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    pushbytes 0x0054
    concat
    frame_dig -2
    len
    pushint 84 // 84
    dig 1
    +
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0x66bb0333 // method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:277-295
    // arc4.emit(
    //     "Swapped",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    frame_dig -16
    len
    pushint 173 // 173
    +
    pushbytes 0x00ad
    frame_dig -15
    concat
    frame_dig -14
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -13
    len
    uncover 2
    +
    swap
    frame_dig -12
    concat
    frame_dig -11
    concat
    dig 1
    itob
    extract 6 2
    concat
    frame_dig -10
    len
    uncover 2
    +
    dup
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -9
    len
    uncover 2
    +
    swap
    frame_dig -8
    concat
    frame_dig -7
    concat
    frame_dig -6
    concat
    frame_dig -5
    concat
    frame_dig -4
    concat
    frame_dig -3
    concat
    dig 1
    itob
    extract 6 2
    concat
    swap
    uncover 2
    +
    itob
    extract 6 2
    concat
    frame_dig -16
    concat
    frame_dig -13
    concat
    frame_dig -10
    concat
    frame_dig -9
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    pushbytes 0xec3319bb // method "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
    swap
    concat
    dup
    log
    // tests/artifacts/Arc4PrimitiveOps/contract.py:296-314
    // arc4.emit(
    //     "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))",
    //     a,
    //     b,
    //     c,
    //     d.copy(),
    //     e,
    //     f,
    //     g.copy(),
    //     h,
    //     m,
    //     n,
    //     o,
    //     p,
    //     q,
    //     arc4_r.copy(),
    //     arc4_s.copy(),
    //     arc4_t,
    // )
    log
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "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",
+        "approval": "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",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [
diff --git a/tests/artifacts/Arrays/data/Contract.approval.teal b/tests/artifacts/Arrays/data/Contract.approval.teal
index 80e4e78b..d93b2619 100644
--- a/tests/artifacts/Arrays/data/Contract.approval.teal
+++ b/tests/artifacts/Arrays/data/Contract.approval.teal
@@ -3,26 +3,38 @@
 
 // algopy.arc4.ARC4Contract.approval_program() -> uint64:
 main:
-    intcblock 8 0 1 5 512
+    intcblock 1 8 0 5 512
     bytecblock 0x 0x000000000000000100000000000000020000000000000003 0x0000000000000000 0x0000000000000004
     pushbytes 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
     store 0
-    // tests/artifacts/Arrays/uint64.py:4
+    // tests/artifacts/Arrays/uint64.py:13
     // class Contract(arc4.ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@15
-    pushbytess 0xa33be873 0xe0c378e9 0x366f509d 0x58351a50 0xfa99e984 0xa20e440f 0x179ac3f9 0xf17f6f0a 0x845e1b4e 0x7621cfd1 // method "test_array()void", method "test_array_extend()void", method "test_array_multiple_append()void", method "overhead()void", method "test_array_too_long()void", method "test_array_copy_and_extend()void", method "test_array_evaluation_order()void", method "test_allocations(uint64)void", method "test_iteration()void", method "test_quicksort()void"
+    bz main_bare_routing@17
+    pushbytess 0xa33be873 0xe0c378e9 0x366f509d 0x58351a50 0xfa99e984 0xa20e440f 0x179ac3f9 0x45dcc836 0xf17f6f0a 0x845e1b4e 0x7621cfd1 0x5661a67c // method "test_array()void", method "test_array_extend()void", method "test_array_multiple_append()void", method "overhead()void", method "test_array_too_long()void", method "test_array_copy_and_extend()void", method "test_array_evaluation_order()void", method "test_array_assignment_maximum_cursage()void", method "test_allocations(uint64)void", method "test_iteration()void", method "test_quicksort()void", method "test_unobserved_write()void"
     txna ApplicationArgs 0
-    match main_test_array_route@3 main_test_array_extend_route@4 main_test_array_multiple_append_route@5 main_overhead_route@6 main_test_array_too_long_route@7 main_test_array_copy_and_extend_route@8 main_test_array_evaluation_order_route@9 main_test_allocations_route@10 main_test_iteration_route@11 main_test_quicksort_route@12
+    match main_test_array_route@3 main_test_array_extend_route@4 main_test_array_multiple_append_route@5 main_overhead_route@6 main_test_array_too_long_route@7 main_test_array_copy_and_extend_route@8 main_test_array_evaluation_order_route@9 main_test_array_assignment_maximum_cursage_route@10 main_test_allocations_route@11 main_test_iteration_route@12 main_test_quicksort_route@13 main_test_unobserved_write_route@14
 
-main_after_if_else@19:
-    // tests/artifacts/Arrays/uint64.py:4
+main_after_if_else@21:
+    // tests/artifacts/Arrays/uint64.py:13
     // class Contract(arc4.ARC4Contract):
-    intc_1 // 0
+    intc_2 // 0
     return
 
-main_test_quicksort_route@12:
-    // tests/artifacts/Arrays/uint64.py:156
+main_test_unobserved_write_route@14:
+    // tests/artifacts/Arrays/uint64.py:191
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub test_unobserved_write
+    intc_0 // 1
+    return
+
+main_test_quicksort_route@13:
+    // tests/artifacts/Arrays/uint64.py:174
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -30,11 +42,11 @@ main_test_quicksort_route@12:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_quicksort
-    intc_2 // 1
+    intc_0 // 1
     return
 
-main_test_iteration_route@11:
-    // tests/artifacts/Arrays/uint64.py:122
+main_test_iteration_route@12:
+    // tests/artifacts/Arrays/uint64.py:140
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -42,29 +54,41 @@ main_test_iteration_route@11:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_iteration
-    intc_2 // 1
+    intc_0 // 1
     return
 
-main_test_allocations_route@10:
-    // tests/artifacts/Arrays/uint64.py:116
+main_test_allocations_route@11:
+    // tests/artifacts/Arrays/uint64.py:134
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/uint64.py:4
+    // tests/artifacts/Arrays/uint64.py:13
     // class Contract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/uint64.py:116
+    // tests/artifacts/Arrays/uint64.py:134
     // @arc4.abimethod()
     callsub test_allocations
-    intc_2 // 1
+    intc_0 // 1
+    return
+
+main_test_array_assignment_maximum_cursage_route@10:
+    // tests/artifacts/Arrays/uint64.py:125
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub test_array_assignment_maximum_cursage
+    intc_0 // 1
     return
 
 main_test_array_evaluation_order_route@9:
-    // tests/artifacts/Arrays/uint64.py:97
+    // tests/artifacts/Arrays/uint64.py:106
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -72,11 +96,11 @@ main_test_array_evaluation_order_route@9:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_array_evaluation_order
-    intc_2 // 1
+    intc_0 // 1
     return
 
 main_test_array_copy_and_extend_route@8:
-    // tests/artifacts/Arrays/uint64.py:75
+    // tests/artifacts/Arrays/uint64.py:84
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -84,11 +108,11 @@ main_test_array_copy_and_extend_route@8:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_array_copy_and_extend
-    intc_2 // 1
+    intc_0 // 1
     return
 
 main_test_array_too_long_route@7:
-    // tests/artifacts/Arrays/uint64.py:66
+    // tests/artifacts/Arrays/uint64.py:75
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -96,22 +120,22 @@ main_test_array_too_long_route@7:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_array_too_long
-    intc_2 // 1
+    intc_0 // 1
     return
 
 main_overhead_route@6:
-    // tests/artifacts/Arrays/uint64.py:62
+    // tests/artifacts/Arrays/uint64.py:71
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    intc_2 // 1
+    intc_0 // 1
     return
 
 main_test_array_multiple_append_route@5:
-    // tests/artifacts/Arrays/uint64.py:53
+    // tests/artifacts/Arrays/uint64.py:62
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -119,11 +143,11 @@ main_test_array_multiple_append_route@5:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_array_multiple_append
-    intc_2 // 1
+    intc_0 // 1
     return
 
 main_test_array_extend_route@4:
-    // tests/artifacts/Arrays/uint64.py:41
+    // tests/artifacts/Arrays/uint64.py:50
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -131,11 +155,11 @@ main_test_array_extend_route@4:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_array_extend
-    intc_2 // 1
+    intc_0 // 1
     return
 
 main_test_array_route@3:
-    // tests/artifacts/Arrays/uint64.py:5
+    // tests/artifacts/Arrays/uint64.py:14
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -143,30 +167,32 @@ main_test_array_route@3:
     txn ApplicationID
     assert // can only call when not creating
     callsub test_array
-    intc_2 // 1
+    intc_0 // 1
     return
 
-main_bare_routing@15:
-    // tests/artifacts/Arrays/uint64.py:4
+main_bare_routing@17:
+    // tests/artifacts/Arrays/uint64.py:13
     // class Contract(arc4.ARC4Contract):
     txn OnCompletion
-    bnz main_after_if_else@19
+    bnz main_after_if_else@21
     txn ApplicationID
     !
     assert // can only call when creating
-    intc_2 // 1
+    intc_0 // 1
     return
 
 
 // tests.artifacts.Arrays.uint64.quicksort_window(arr: uint64, window_left: uint64, window_right: uint64) -> void:
 quicksort_window:
-    // tests/artifacts/Arrays/uint64.py:174-175
+    // tests/artifacts/Arrays/uint64.py:201-204
     // @subroutine
-    // def quicksort_window(arr: Array[UInt64], window_left: UInt64, window_right: UInt64) -> None:
+    // def quicksort_window(
+    //     arr: ReferenceArray[UInt64], window_left: UInt64, window_right: UInt64
+    // ) -> None:
     proto 3 0
     bytec_0 // ""
     dupn 2
-    // tests/artifacts/Arrays/uint64.py:178
+    // tests/artifacts/Arrays/uint64.py:207
     // pivot = arr[(window_left + window_right) // 2]
     frame_dig -2
     frame_dig -1
@@ -176,81 +202,72 @@ quicksort_window:
     frame_dig -3
     loads
     swap
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     frame_dig -1
     frame_dig -2
 
 quicksort_window_while_top@3:
-    // tests/artifacts/Arrays/uint64.py:182-183
+    // tests/artifacts/Arrays/uint64.py:211-212
     // # move left of window towards pivot
     // while arr[left] < pivot:
     frame_dig -3
     loads
     frame_dig 5
-    intc_0 // 8
+    intc_1 // 8
     *
     dup
     frame_bury 0
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     frame_dig 3
     <
     bz quicksort_window_while_top@6
-    // tests/artifacts/Arrays/uint64.py:184
+    // tests/artifacts/Arrays/uint64.py:213
     // left += 1
     frame_dig 5
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 5
     b quicksort_window_while_top@3
 
 quicksort_window_while_top@6:
-    // tests/artifacts/Arrays/uint64.py:185-186
+    // tests/artifacts/Arrays/uint64.py:214-215
     // # move right of window towards pivot
     // while pivot < arr[right]:
     frame_dig -3
     loads
     frame_dig 4
-    intc_0 // 8
+    intc_1 // 8
     *
     dup
     frame_bury 1
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     frame_dig 3
     >
     bz quicksort_window_after_while@10
-    // tests/artifacts/Arrays/uint64.py:187-188
+    // tests/artifacts/Arrays/uint64.py:216-217
     // # break out of loop if right would go negative
     // if not right:
     frame_dig 4
     bz quicksort_window_after_while@22
-    // tests/artifacts/Arrays/uint64.py:190
+    // tests/artifacts/Arrays/uint64.py:219
     // right -= 1
     frame_dig 4
-    intc_2 // 1
+    intc_0 // 1
     -
     frame_bury 4
     b quicksort_window_while_top@6
 
 quicksort_window_after_while@22:
-    // tests/artifacts/Arrays/uint64.py:218-219
+    // tests/artifacts/Arrays/uint64.py:247-248
     // # sort left half of window
     // if window_left < right:
     frame_dig -2
     frame_dig 4
     <
     bz quicksort_window_after_if_else@24
-    // tests/artifacts/Arrays/uint64.py:220
+    // tests/artifacts/Arrays/uint64.py:249
     // quicksort_window(arr, window_left, right)
     frame_dig -3
     frame_dig -2
@@ -258,14 +275,14 @@ quicksort_window_after_while@22:
     callsub quicksort_window
 
 quicksort_window_after_if_else@24:
-    // tests/artifacts/Arrays/uint64.py:221-222
+    // tests/artifacts/Arrays/uint64.py:250-251
     // # sort right half of window
     // if left < window_right:
     frame_dig 5
     frame_dig -1
     <
     bz quicksort_window_after_if_else@26
-    // tests/artifacts/Arrays/uint64.py:223
+    // tests/artifacts/Arrays/uint64.py:252
     // quicksort_window(arr, left, window_right)
     frame_dig -3
     frame_dig 5
@@ -276,14 +293,14 @@ quicksort_window_after_if_else@26:
     retsub
 
 quicksort_window_after_while@10:
-    // tests/artifacts/Arrays/uint64.py:192-193
+    // tests/artifacts/Arrays/uint64.py:221-222
     // # if window isn't empty then swap values and move window in
     // if left < right:
     frame_dig 5
     frame_dig 4
     <
     bz quicksort_window_after_if_else@16
-    // tests/artifacts/Arrays/uint64.py:194
+    // tests/artifacts/Arrays/uint64.py:223
     // arr[left], arr[right] = arr[right], arr[left]
     frame_dig -3
     loads
@@ -291,51 +308,40 @@ quicksort_window_after_while@10:
     frame_dig 1
     dup
     cover 3
-    intc_0 // 8
-    extract3
-    intc_1 // 0
-    extract_uint64
+    intc_1 // 8
+    extract3 // on error: index access is out of bounds
     dig 1
     frame_dig 0
     dup
-    cover 4
-    intc_0 // 8
-    extract3
-    intc_1 // 0
-    extract_uint64
-    swap
-    itob
-    uncover 2
-    uncover 3
-    uncover 2
+    cover 3
+    intc_1 // 8
+    extract3 // on error: index access is out of bounds
+    cover 3
     replace3
-    swap
-    itob
-    swap
     cover 2
     replace3
     frame_dig -3
     swap
     stores
-    // tests/artifacts/Arrays/uint64.py:195
+    // tests/artifacts/Arrays/uint64.py:224
     // left += 1
     frame_dig 5
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 5
-    // tests/artifacts/Arrays/uint64.py:196-197
+    // tests/artifacts/Arrays/uint64.py:225-226
     // # break out of loop if right would go negative
     // if not right:
     frame_dig 4
     bz quicksort_window_after_while@22
-    // tests/artifacts/Arrays/uint64.py:199
+    // tests/artifacts/Arrays/uint64.py:228
     // right -= 1
     frame_dig 4
-    intc_2 // 1
+    intc_0 // 1
     -
     dup
     frame_bury 4
-    // tests/artifacts/Arrays/uint64.py:200-201
+    // tests/artifacts/Arrays/uint64.py:229-230
     // # explicit continue to avoid hitting outer break
     // if left <= right:
     frame_dig 5
@@ -344,75 +350,146 @@ quicksort_window_after_while@10:
     b quicksort_window_after_while@22
 
 quicksort_window_after_if_else@16:
-    // tests/artifacts/Arrays/uint64.py:206-207
+    // tests/artifacts/Arrays/uint64.py:235-236
     // # if window is just one item, don't bother swapping, but still adjust window
     // if left == right:
     frame_dig 5
     frame_dig 4
     ==
     bz quicksort_window_after_while@22
-    // tests/artifacts/Arrays/uint64.py:208
+    // tests/artifacts/Arrays/uint64.py:237
     // left += 1
     frame_dig 5
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 5
     frame_dig 4
     dup
     frame_bury 2
-    // tests/artifacts/Arrays/uint64.py:209-210
+    // tests/artifacts/Arrays/uint64.py:238-239
     // # don't decrement right if it would go negative
     // if right:
     bz quicksort_window_after_if_else@19
-    // tests/artifacts/Arrays/uint64.py:211
+    // tests/artifacts/Arrays/uint64.py:240
     // right -= 1
     frame_dig 4
-    intc_2 // 1
+    intc_0 // 1
     -
     frame_bury 2
 
 quicksort_window_after_if_else@19:
     frame_dig 2
     frame_bury 4
-    // tests/artifacts/Arrays/uint64.py:212-214
+    // tests/artifacts/Arrays/uint64.py:241-243
     // # loop always ends in this scenario
     // # and an explict break consumes fewer ops
     // break
     b quicksort_window_after_while@22
 
 
+// tests.artifacts.Arrays.uint64.create_array() -> uint64:
+create_array:
+    // tests/artifacts/Arrays/uint64.py:255-256
+    // @subroutine(inline=False)
+    // def create_array() -> ReferenceArray[UInt64]:
+    proto 0 1
+    // tests/artifacts/Arrays/uint64.py:257
+    // arr = ReferenceArray[UInt64]()
+    callsub _puya_lib.mem.new_slot
+    dup
+    bytec_0 // 0x
+    stores
+    // tests/artifacts/Arrays/uint64.py:258
+    // for i in urange(5):
+    intc_2 // 0
+
+create_array_for_header@1:
+    // tests/artifacts/Arrays/uint64.py:258
+    // for i in urange(5):
+    frame_dig 1
+    intc_3 // 5
+    <
+    bz create_array_after_for@4
+    // tests/artifacts/Arrays/uint64.py:259
+    // arr.append(i)
+    frame_dig 0
+    dup
+    loads
+    frame_dig 1
+    dup
+    cover 3
+    itob
+    concat // on error: max array length exceeded
+    stores
+    // tests/artifacts/Arrays/uint64.py:258
+    // for i in urange(5):
+    intc_0 // 1
+    +
+    frame_bury 1
+    b create_array_for_header@1
+
+create_array_after_for@4:
+    // tests/artifacts/Arrays/uint64.py:260
+    // return arr
+    retsub
+
+
+// tests.artifacts.Arrays.uint64.assert_last_is_zero(arr: uint64) -> void:
+assert_last_is_zero:
+    // tests/artifacts/Arrays/uint64.py:263-264
+    // @subroutine(inline=False)
+    // def assert_last_is_zero(arr: ReferenceArray[UInt64]) -> None:
+    proto 1 0
+    // tests/artifacts/Arrays/uint64.py:265
+    // assert arr[arr.length - 1] == 0
+    frame_dig -1
+    loads
+    dup
+    len
+    intc_1 // 8
+    /
+    intc_0 // 1
+    -
+    intc_1 // 8
+    *
+    extract_uint64
+    !
+    assert
+    retsub
+
+
 // tests.artifacts.Arrays.uint64.add_x(arr: uint64, x: uint64) -> void:
 add_x:
-    // tests/artifacts/Arrays/uint64.py:233-234
+    // tests/artifacts/Arrays/uint64.py:277-278
     // @subroutine
-    // def add_x(arr: Array[UInt64], x: UInt64) -> None:
+    // def add_x(arr: ReferenceArray[UInt64], x: UInt64) -> None:
     proto 2 0
-    // tests/artifacts/Arrays/uint64.py:235
+    // tests/artifacts/Arrays/uint64.py:279
     // for i in urange(x):
-    intc_1 // 0
+    intc_2 // 0
 
 add_x_for_header@1:
-    // tests/artifacts/Arrays/uint64.py:235
+    // tests/artifacts/Arrays/uint64.py:279
     // for i in urange(x):
     frame_dig 0
     frame_dig -1
     <
     bz add_x_after_for@4
-    // tests/artifacts/Arrays/uint64.py:236
+    // tests/artifacts/Arrays/uint64.py:280
     // arr.append(i)
+    frame_dig -2
+    loads
     frame_dig 0
     dup
+    cover 2
     itob
-    frame_dig -2
-    loads
-    swap
     concat // on error: max array length exceeded
     frame_dig -2
     swap
     stores
-    // tests/artifacts/Arrays/uint64.py:235
+    // tests/artifacts/Arrays/uint64.py:279
     // for i in urange(x):
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 0
     b add_x_for_header@1
@@ -423,24 +500,24 @@ add_x_after_for@4:
 
 // tests.artifacts.Arrays.uint64.append_length_and_return(arr: uint64) -> uint64:
 append_length_and_return:
-    // tests/artifacts/Arrays/uint64.py:247-248
+    // tests/artifacts/Arrays/uint64.py:291-292
     // @subroutine
-    // def append_length_and_return(arr: Array[UInt64]) -> Array[UInt64]:
+    // def append_length_and_return(arr: ReferenceArray[UInt64]) -> ReferenceArray[UInt64]:
     proto 1 1
-    // tests/artifacts/Arrays/uint64.py:249
+    // tests/artifacts/Arrays/uint64.py:293
     // arr.append(arr.length)
     frame_dig -1
     loads
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     itob
     concat // on error: max array length exceeded
     frame_dig -1
     swap
     stores
-    // tests/artifacts/Arrays/uint64.py:250
+    // tests/artifacts/Arrays/uint64.py:294
     // return arr
     frame_dig -1
     retsub
@@ -448,261 +525,239 @@ append_length_and_return:
 
 // tests.artifacts.Arrays.uint64.Contract.test_array() -> void:
 test_array:
-    // tests/artifacts/Arrays/uint64.py:5-6
+    // tests/artifacts/Arrays/uint64.py:14-15
     // @arc4.abimethod()
     // def test_array(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/uint64.py:7
-    // arr = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:16
+    // arr = ReferenceArray[UInt64]()
     callsub _puya_lib.mem.new_slot
     dup
-    // tests/artifacts/Arrays/uint64.py:10
+    // tests/artifacts/Arrays/uint64.py:19
     // arr.append(UInt64(42))
     pushint 42 // 42
     itob
     dig 1
     swap
     stores
-    // tests/artifacts/Arrays/uint64.py:14
+    // tests/artifacts/Arrays/uint64.py:23
     // add_x(arr, UInt64(5))
     dup
     intc_3 // 5
     callsub add_x
-    // tests/artifacts/Arrays/uint64.py:15
+    // tests/artifacts/Arrays/uint64.py:24
     // assert arr.length == 6
     loads
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 6 // 6
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:16
+    // tests/artifacts/Arrays/uint64.py:25
     // assert arr[-1] == 4
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:18
+    // tests/artifacts/Arrays/uint64.py:27
     // pop_x(arr, x=UInt64(3), expected=UInt64(4))
     pushint 4 // 4
-    // tests/artifacts/Arrays/uint64.py:241
+    // tests/artifacts/Arrays/uint64.py:285
     // for _i in urange(x):
-    intc_1 // 0
+    intc_2 // 0
 
 test_array_for_header@2:
-    // tests/artifacts/Arrays/uint64.py:241
+    // tests/artifacts/Arrays/uint64.py:285
     // for _i in urange(x):
     frame_dig 2
-    // tests/artifacts/Arrays/uint64.py:18
+    // tests/artifacts/Arrays/uint64.py:27
     // pop_x(arr, x=UInt64(3), expected=UInt64(4))
     pushint 3 // 3
-    // tests/artifacts/Arrays/uint64.py:241
+    // tests/artifacts/Arrays/uint64.py:285
     // for _i in urange(x):
     <
     bz test_array_after_for@4
-    // tests/artifacts/Arrays/uint64.py:242
+    // tests/artifacts/Arrays/uint64.py:286
     // popped = arr.pop()
     frame_dig 0
     dup
     loads
     dup
     len
-    intc_0 // 8
-    -
     dup
-    intc_0 // 8
-    /
+    intc_1 // 8
+    -
     dig 2
-    intc_1 // 0
+    dig 1
     uncover 3
-    extract3
-    swap
-    intc_0 // 8
-    *
+    substring3
     uncover 2
-    swap
-    intc_0 // 8
+    intc_2 // 0
+    uncover 3
     extract3
-    intc_1 // 0
-    extract_uint64
+    swap
+    btoi
     cover 2
     stores
-    // tests/artifacts/Arrays/uint64.py:243
+    // tests/artifacts/Arrays/uint64.py:287
     // assert popped == expected
     frame_dig 1
     dup
     cover 2
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:244
+    // tests/artifacts/Arrays/uint64.py:288
     // expected -= 1
-    intc_2 // 1
+    intc_0 // 1
     -
     frame_bury 1
-    // tests/artifacts/Arrays/uint64.py:241
+    // tests/artifacts/Arrays/uint64.py:285
     // for _i in urange(x):
     frame_dig 2
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 2
     b test_array_for_header@2
 
 test_array_after_for@4:
-    // tests/artifacts/Arrays/uint64.py:19
+    // tests/artifacts/Arrays/uint64.py:28
     // assert arr.length == 3
     frame_dig 0
     dup
     loads
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 3 // 3
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:20
+    // tests/artifacts/Arrays/uint64.py:29
     // assert arr[-1] == 1
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
-    intc_2 // 1
+    intc_0 // 1
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:22
+    // tests/artifacts/Arrays/uint64.py:31
     // arr.append(UInt64(43))
     pushint 43 // 43
     itob
     concat // on error: max array length exceeded
     dup2
     stores
-    // tests/artifacts/Arrays/uint64.py:23
+    // tests/artifacts/Arrays/uint64.py:32
     // assert arr.length == 4
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:24
+    // tests/artifacts/Arrays/uint64.py:33
     // assert arr[-1] == 43
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 43 // 43
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:25
+    // tests/artifacts/Arrays/uint64.py:34
     // assert arr[0] == 42
-    extract 0 8
-    intc_1 // 0
+    intc_2 // 0
     extract_uint64
     pushint 42 // 42
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:27
+    // tests/artifacts/Arrays/uint64.py:36
     // add_x(arr, UInt64(10))
     dup
     pushint 10 // 10
     callsub add_x
-    // tests/artifacts/Arrays/uint64.py:28
+    // tests/artifacts/Arrays/uint64.py:37
     // assert arr.length == 14
     dup
     loads
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 14 // 14
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:29
+    // tests/artifacts/Arrays/uint64.py:38
     // assert arr[-1] == 9
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 9 // 9
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:31
+    // tests/artifacts/Arrays/uint64.py:40
     // arr.append(UInt64(44))
     pushint 44 // 44
     itob
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:32
+    // tests/artifacts/Arrays/uint64.py:41
     // assert arr.length == 15
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 15 // 15
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:33
+    // tests/artifacts/Arrays/uint64.py:42
     // assert arr[-1] == 44
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 44 // 44
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:228
+    // tests/artifacts/Arrays/uint64.py:272
     // arr.append(UInt64(99))
     pushint 99 // 99
     itob
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:229
+    // tests/artifacts/Arrays/uint64.py:273
     // arr2.append(UInt64(100))
     pushint 100 // 100
     itob
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:35
+    // tests/artifacts/Arrays/uint64.py:44
     // return_ref(arr, arr)[0] += 2
     dup
-    extract 0 8
-    intc_1 // 0
+    intc_2 // 0
     extract_uint64
     pushint 2 // 2
     +
@@ -711,50 +766,43 @@ test_array_after_for@4:
     swap
     dig 1
     stores
-    // tests/artifacts/Arrays/uint64.py:36
+    // tests/artifacts/Arrays/uint64.py:45
     // assert arr.length == 17
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 17 // 17
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:37
+    // tests/artifacts/Arrays/uint64.py:46
     // assert arr[0] == 44
     dig 1
-    extract 0 8
-    intc_1 // 0
+    intc_2 // 0
     extract_uint64
     pushint 44 // 44
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:38
+    // tests/artifacts/Arrays/uint64.py:47
     // assert arr[-2] == 99
     dup
     pushint 2 // 2
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 2
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 99 // 99
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:39
+    // tests/artifacts/Arrays/uint64.py:48
     // assert arr[-1] == 100
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 100 // 100
     ==
@@ -764,38 +812,38 @@ test_array_after_for@4:
 
 // tests.artifacts.Arrays.uint64.Contract.test_array_extend() -> void:
 test_array_extend:
-    // tests/artifacts/Arrays/uint64.py:43
-    // arr = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:52
+    // arr = ReferenceArray[UInt64]()
     callsub _puya_lib.mem.new_slot
     dup
     bytec_0 // 0x
     stores
-    // tests/artifacts/Arrays/uint64.py:44
+    // tests/artifacts/Arrays/uint64.py:53
     // add_x(arr, UInt64(1))
     dup
-    intc_2 // 1
+    intc_0 // 1
     callsub add_x
-    // tests/artifacts/Arrays/uint64.py:48
+    // tests/artifacts/Arrays/uint64.py:57
     // arr2.append(UInt64(3))
     bytec_1 // 0x000000000000000100000000000000020000000000000003
     pop
-    // tests/artifacts/Arrays/uint64.py:50
+    // tests/artifacts/Arrays/uint64.py:59
     // arr.extend(arr2)
     dup
     loads
-    // tests/artifacts/Arrays/uint64.py:48
+    // tests/artifacts/Arrays/uint64.py:57
     // arr2.append(UInt64(3))
     bytec_1 // 0x000000000000000100000000000000020000000000000003
-    // tests/artifacts/Arrays/uint64.py:50
+    // tests/artifacts/Arrays/uint64.py:59
     // arr.extend(arr2)
     concat // on error: max array length exceeded
     swap
     dig 1
     stores
-    // tests/artifacts/Arrays/uint64.py:51
+    // tests/artifacts/Arrays/uint64.py:60
     // assert arr.length == 4
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     pushint 4 // 4
     ==
@@ -805,31 +853,30 @@ test_array_extend:
 
 // tests.artifacts.Arrays.uint64.Contract.test_array_multiple_append() -> void:
 test_array_multiple_append:
-    // tests/artifacts/Arrays/uint64.py:55
-    // arr = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:64
+    // arr = ReferenceArray[UInt64]()
     callsub _puya_lib.mem.new_slot
     dup
     bytec_0 // 0x
     stores
-    // tests/artifacts/Arrays/uint64.py:56
+    // tests/artifacts/Arrays/uint64.py:65
     // add_x(arr, UInt64(1))
     dup
-    intc_2 // 1
+    intc_0 // 1
     callsub add_x
-    // tests/artifacts/Arrays/uint64.py:57
+    // tests/artifacts/Arrays/uint64.py:66
     // arr.append(UInt64(1))
-    intc_2 // 1
-    itob
-    dig 1
+    dup
     loads
-    swap
+    intc_0 // 1
+    itob
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:58
+    // tests/artifacts/Arrays/uint64.py:67
     // arr.append(UInt64(2))
     pushint 2 // 2
     itob
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:59
+    // tests/artifacts/Arrays/uint64.py:68
     // arr.append(UInt64(3))
     pushint 3 // 3
     itob
@@ -837,10 +884,10 @@ test_array_multiple_append:
     swap
     dig 1
     stores
-    // tests/artifacts/Arrays/uint64.py:60
+    // tests/artifacts/Arrays/uint64.py:69
     // assert arr.length == 4
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     pushint 4 // 4
     ==
@@ -850,52 +897,52 @@ test_array_multiple_append:
 
 // tests.artifacts.Arrays.uint64.Contract.test_array_too_long() -> void:
 test_array_too_long:
-    // tests/artifacts/Arrays/uint64.py:66-67
+    // tests/artifacts/Arrays/uint64.py:75-76
     // @arc4.abimethod()
     // def test_array_too_long(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/uint64.py:68
-    // array = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:77
+    // array = ReferenceArray[UInt64]()
     bytec_0 // 0x
-    // tests/artifacts/Arrays/uint64.py:69
+    // tests/artifacts/Arrays/uint64.py:78
     // for i in urange(512):
-    intc_1 // 0
+    intc_2 // 0
 
 test_array_too_long_for_header@1:
-    // tests/artifacts/Arrays/uint64.py:69
+    // tests/artifacts/Arrays/uint64.py:78
     // for i in urange(512):
     frame_dig 1
     intc 4 // 512
     <
     bz test_array_too_long_after_for@4
-    // tests/artifacts/Arrays/uint64.py:70
+    frame_dig 0
+    // tests/artifacts/Arrays/uint64.py:79
     // array.append(i)
     frame_dig 1
     dup
+    cover 2
     itob
-    frame_dig 0
-    swap
     concat // on error: max array length exceeded
     frame_bury 0
-    // tests/artifacts/Arrays/uint64.py:69
+    // tests/artifacts/Arrays/uint64.py:78
     // for i in urange(512):
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 1
     b test_array_too_long_for_header@1
 
 test_array_too_long_after_for@4:
     frame_dig 0
-    // tests/artifacts/Arrays/uint64.py:71
+    // tests/artifacts/Arrays/uint64.py:80
     // assert array.length == 512, "array is expected length"
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     intc 4 // 512
     ==
     assert // array is expected length
-    // tests/artifacts/Arrays/uint64.py:73
+    // tests/artifacts/Arrays/uint64.py:82
     // array.append(UInt64(512))  # this will fail
     intc 4 // 512
     itob
@@ -906,36 +953,36 @@ test_array_too_long_after_for@4:
 
 // tests.artifacts.Arrays.uint64.Contract.test_array_copy_and_extend() -> void:
 test_array_copy_and_extend:
-    // tests/artifacts/Arrays/uint64.py:75-76
+    // tests/artifacts/Arrays/uint64.py:84-85
     // @arc4.abimethod()
     // def test_array_copy_and_extend(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/uint64.py:77
-    // array = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:86
+    // array = ReferenceArray[UInt64]()
     bytec_0 // 0x
-    // tests/artifacts/Arrays/uint64.py:78
+    // tests/artifacts/Arrays/uint64.py:87
     // for i in urange(5):
-    intc_1 // 0
+    intc_2 // 0
 
 test_array_copy_and_extend_for_header@1:
-    // tests/artifacts/Arrays/uint64.py:78
+    // tests/artifacts/Arrays/uint64.py:87
     // for i in urange(5):
     frame_dig 1
     intc_3 // 5
     <
     bz test_array_copy_and_extend_after_for@4
-    // tests/artifacts/Arrays/uint64.py:79
+    frame_dig 0
+    // tests/artifacts/Arrays/uint64.py:88
     // array.append(i)
     frame_dig 1
     dup
+    cover 2
     itob
-    frame_dig 0
-    swap
     concat // on error: max array length exceeded
     frame_bury 0
-    // tests/artifacts/Arrays/uint64.py:78
+    // tests/artifacts/Arrays/uint64.py:87
     // for i in urange(5):
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 1
     b test_array_copy_and_extend_for_header@1
@@ -943,121 +990,109 @@ test_array_copy_and_extend_for_header@1:
 test_array_copy_and_extend_after_for@4:
     frame_dig 0
     dup
-    // tests/artifacts/Arrays/uint64.py:82
+    // tests/artifacts/Arrays/uint64.py:91
     // array.append(UInt64(5))
     intc_3 // 5
     itob
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:83
+    // tests/artifacts/Arrays/uint64.py:92
     // assert array.length == 6
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 6 // 6
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:84
+    // tests/artifacts/Arrays/uint64.py:93
     // assert array[-1] == 5, "expected 5"
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     intc_3 // 5
     ==
     assert // expected 5
     dig 1
-    // tests/artifacts/Arrays/uint64.py:86
+    // tests/artifacts/Arrays/uint64.py:95
     // assert array2.length == 5
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     intc_3 // 5
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:87
+    // tests/artifacts/Arrays/uint64.py:96
     // assert array2[-1] == 4, "expected 4"
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 4 // 4
     ==
     assert // expected 4
-    // tests/artifacts/Arrays/uint64.py:89
+    // tests/artifacts/Arrays/uint64.py:98
     // array.extend(array2)
     concat // on error: max array length exceeded
-    // tests/artifacts/Arrays/uint64.py:90
+    // tests/artifacts/Arrays/uint64.py:99
     // assert array.length == 11
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 11 // 11
     ==
     assert
     uncover 2
-    // tests/artifacts/Arrays/uint64.py:91
+    // tests/artifacts/Arrays/uint64.py:100
     // assert array2.length == 5
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     intc_3 // 5
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:92
+    // tests/artifacts/Arrays/uint64.py:101
     // assert array[-1] == 4, "expected 4"
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
     dig 1
     swap
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
     pushint 4 // 4
     ==
     assert // expected 4
-    // tests/artifacts/Arrays/uint64.py:93
+    // tests/artifacts/Arrays/uint64.py:102
     // assert array[4] == 4, "expected 4"
     dup
-    extract 32 8
-    intc_1 // 0
+    pushint 32 // 32
     extract_uint64
     pushint 4 // 4
     ==
     assert // expected 4
-    // tests/artifacts/Arrays/uint64.py:94
+    // tests/artifacts/Arrays/uint64.py:103
     // assert array[5] == 5, "expected 4"
     dup
-    extract 40 8
-    intc_1 // 0
+    pushint 40 // 40
     extract_uint64
     intc_3 // 5
     ==
     assert // expected 4
-    // tests/artifacts/Arrays/uint64.py:95
+    // tests/artifacts/Arrays/uint64.py:104
     // assert array[6] == 0, "expected 4"
-    extract 48 8
-    intc_1 // 0
+    pushint 48 // 48
     extract_uint64
     !
     assert // expected 4
@@ -1066,17 +1101,17 @@ test_array_copy_and_extend_after_for@4:
 
 // tests.artifacts.Arrays.uint64.Contract.test_array_evaluation_order() -> void:
 test_array_evaluation_order:
-    // tests/artifacts/Arrays/uint64.py:99
-    // arr = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:108
+    // arr = ReferenceArray[UInt64]()
     callsub _puya_lib.mem.new_slot
-    // tests/artifacts/Arrays/uint64.py:100
+    // tests/artifacts/Arrays/uint64.py:109
     // arr.append(UInt64(3))
     pushint 3 // 3
     itob
     dig 1
     swap
     stores
-    // tests/artifacts/Arrays/uint64.py:101
+    // tests/artifacts/Arrays/uint64.py:110
     // append_length_and_return(arr).extend(append_length_and_return(arr))
     dup
     callsub append_length_and_return
@@ -1088,135 +1123,122 @@ test_array_evaluation_order:
     swap
     concat // on error: max array length exceeded
     stores
-    // tests/artifacts/Arrays/uint64.py:102
+    // tests/artifacts/Arrays/uint64.py:111
     // assert arr.length == 6
     dup
     loads
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     pushint 6 // 6
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:103
+    // tests/artifacts/Arrays/uint64.py:112
     // assert arr[0] == 3
     dup
-    extract 0 8
-    intc_1 // 0
+    intc_2 // 0
     extract_uint64
     pushint 3 // 3
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:104
+    // tests/artifacts/Arrays/uint64.py:113
     // assert arr[1] == 1
     dup
-    extract 8 8
-    intc_1 // 0
+    intc_1 // 8
     extract_uint64
-    intc_2 // 1
+    intc_0 // 1
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:105
+    // tests/artifacts/Arrays/uint64.py:114
     // assert arr[2] == 2
     dup
-    extract 16 8
-    intc_1 // 0
+    pushint 16 // 16
     extract_uint64
     pushint 2 // 2
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:106
+    // tests/artifacts/Arrays/uint64.py:115
     // assert arr[3] == 3
     dup
-    extract 24 8
-    intc_1 // 0
+    pushint 24 // 24
     extract_uint64
     pushint 3 // 3
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:107
+    // tests/artifacts/Arrays/uint64.py:116
     // assert arr[4] == 1
     dup
-    extract 32 8
-    intc_1 // 0
+    pushint 32 // 32
     extract_uint64
-    intc_2 // 1
+    intc_0 // 1
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:108
+    // tests/artifacts/Arrays/uint64.py:117
     // assert arr[5] == 2
-    extract 40 8
-    intc_1 // 0
+    pushint 40 // 40
     extract_uint64
     pushint 2 // 2
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:110
+    // tests/artifacts/Arrays/uint64.py:119
     // arr[append_length_and_return(arr)[0]] = append_length_and_return(arr)[-1]
     dup
     callsub append_length_and_return
     loads
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
-    intc_2 // 1
+    intc_0 // 1
     -
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
-    extract_uint64
+    intc_1 // 8
+    extract3 // on error: index access is out of bounds
     dig 1
     callsub append_length_and_return
     loads
-    extract 0 8
-    intc_1 // 0
+    intc_2 // 0
     extract_uint64
     dig 2
     loads
     swap
-    intc_0 // 8
+    intc_1 // 8
     *
     uncover 2
-    itob
     replace3
     swap
     dig 1
     stores
-    // tests/artifacts/Arrays/uint64.py:111
+    // tests/artifacts/Arrays/uint64.py:120
     // assert arr.length == 8
     dup
     len
-    intc_0 // 8
+    intc_1 // 8
     /
-    intc_0 // 8
+    intc_1 // 8
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:112
+    // tests/artifacts/Arrays/uint64.py:121
     // assert arr[6] == 6
     dup
-    extract 48 8
-    intc_1 // 0
+    pushint 48 // 48
     extract_uint64
     pushint 6 // 6
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:113
+    // tests/artifacts/Arrays/uint64.py:122
     // assert arr[7] == 7
     dup
-    extract 56 8
-    intc_1 // 0
+    pushint 56 // 56
     extract_uint64
     pushint 7 // 7
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:114
+    // tests/artifacts/Arrays/uint64.py:123
     // assert arr[3] == 6
-    extract 24 8
-    intc_1 // 0
+    pushint 24 // 24
     extract_uint64
     pushint 6 // 6
     ==
@@ -1224,37 +1246,88 @@ test_array_evaluation_order:
     retsub
 
 
+// tests.artifacts.Arrays.uint64.Contract.test_array_assignment_maximum_cursage() -> void:
+test_array_assignment_maximum_cursage:
+    // tests/artifacts/Arrays/uint64.py:127
+    // arr = ReferenceArray[UInt64]()
+    callsub _puya_lib.mem.new_slot
+    // tests/artifacts/Arrays/uint64.py:128
+    // arr.append(UInt64(3))
+    pushint 3 // 3
+    itob
+    dig 1
+    swap
+    stores
+    // tests/artifacts/Arrays/uint64.py:129
+    // append_length_and_return(arr)[0] = UInt64(42)
+    dup
+    callsub append_length_and_return
+    pushint 42 // 42
+    itob
+    dig 1
+    loads
+    swap
+    replace2 0
+    stores
+    // tests/artifacts/Arrays/uint64.py:130
+    // assert arr.length == 2
+    loads
+    dup
+    len
+    intc_1 // 8
+    /
+    pushint 2 // 2
+    ==
+    assert
+    // tests/artifacts/Arrays/uint64.py:131
+    // assert arr[0] == 42
+    dup
+    intc_2 // 0
+    extract_uint64
+    pushint 42 // 42
+    ==
+    assert
+    // tests/artifacts/Arrays/uint64.py:132
+    // assert arr[1] == 1
+    intc_1 // 8
+    extract_uint64
+    intc_0 // 1
+    ==
+    assert
+    retsub
+
+
 // tests.artifacts.Arrays.uint64.Contract.test_allocations(num: uint64) -> void:
 test_allocations:
-    // tests/artifacts/Arrays/uint64.py:116-117
+    // tests/artifacts/Arrays/uint64.py:134-135
     // @arc4.abimethod()
     // def test_allocations(self, num: UInt64) -> None:
     proto 1 0
-    // tests/artifacts/Arrays/uint64.py:118
+    // tests/artifacts/Arrays/uint64.py:136
     // for _i in urange(num):
-    intc_1 // 0
+    intc_2 // 0
 
 test_allocations_for_header@1:
-    // tests/artifacts/Arrays/uint64.py:118
+    // tests/artifacts/Arrays/uint64.py:136
     // for _i in urange(num):
     frame_dig 0
     frame_dig -1
     <
     bz test_allocations_after_for@4
-    // tests/artifacts/Arrays/uint64.py:119
-    // alloc_test = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:137
+    // alloc_test = ReferenceArray[UInt64]()
     callsub _puya_lib.mem.new_slot
     dup
     bytec_0 // 0x
     stores
-    // tests/artifacts/Arrays/uint64.py:120
+    // tests/artifacts/Arrays/uint64.py:138
     // add_x(alloc_test, UInt64(1))
-    intc_2 // 1
+    intc_0 // 1
     callsub add_x
-    // tests/artifacts/Arrays/uint64.py:118
+    // tests/artifacts/Arrays/uint64.py:136
     // for _i in urange(num):
     frame_dig 0
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 0
     b test_allocations_for_header@1
@@ -1265,65 +1338,65 @@ test_allocations_after_for@4:
 
 // tests.artifacts.Arrays.uint64.Contract.test_iteration() -> void:
 test_iteration:
-    // tests/artifacts/Arrays/uint64.py:122-123
+    // tests/artifacts/Arrays/uint64.py:140-141
     // @arc4.abimethod()
     // def test_iteration(self) -> None:
     proto 0 0
-    intc_1 // 0
+    intc_2 // 0
     dup
     bytec_0 // ""
-    // tests/artifacts/Arrays/uint64.py:124
-    // arr = Array[UInt64]()
+    // tests/artifacts/Arrays/uint64.py:142
+    // arr = ReferenceArray[UInt64]()
     dupn 7
-    // tests/artifacts/Arrays/uint64.py:125
+    // tests/artifacts/Arrays/uint64.py:143
     // for val in urange(5):
-    intc_1 // 0
+    intc_2 // 0
 
 test_iteration_for_header@1:
-    // tests/artifacts/Arrays/uint64.py:125
+    // tests/artifacts/Arrays/uint64.py:143
     // for val in urange(5):
     frame_dig 10
     intc_3 // 5
     <
     bz test_iteration_after_for@4
-    // tests/artifacts/Arrays/uint64.py:126
+    frame_dig 9
+    // tests/artifacts/Arrays/uint64.py:144
     // arr.append(val)
     frame_dig 10
     dup
+    cover 2
     itob
-    frame_dig 9
-    swap
     concat // on error: max array length exceeded
     frame_bury 9
-    // tests/artifacts/Arrays/uint64.py:125
+    // tests/artifacts/Arrays/uint64.py:143
     // for val in urange(5):
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 10
     b test_iteration_for_header@1
 
 test_iteration_after_for@4:
     frame_dig 9
-    // tests/artifacts/Arrays/uint64.py:127
+    // tests/artifacts/Arrays/uint64.py:145
     // assert arr.length == 5, "expected array of length 5"
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     frame_bury 2
     intc_3 // 5
     ==
     assert // expected array of length 5
-    // tests/artifacts/Arrays/uint64.py:129-130
+    // tests/artifacts/Arrays/uint64.py:147-148
     // # iterate
     // last = UInt64(0)
-    intc_1 // 0
+    intc_2 // 0
     frame_bury 7
-    intc_1 // 0
+    intc_2 // 0
     frame_bury 6
 
 test_iteration_for_header@5:
-    // tests/artifacts/Arrays/uint64.py:131
+    // tests/artifacts/Arrays/uint64.py:149
     // for value in arr:
     frame_dig 6
     frame_dig 2
@@ -1333,20 +1406,17 @@ test_iteration_for_header@5:
     frame_dig 6
     dup
     cover 2
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
-    // tests/artifacts/Arrays/uint64.py:132
+    // tests/artifacts/Arrays/uint64.py:150
     // assert value >= last, "array is not sorted"
     dup
     frame_dig 7
     >=
     assert // array is not sorted
     swap
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 6
     frame_bury 7
@@ -1354,18 +1424,18 @@ test_iteration_for_header@5:
 
 test_iteration_after_for@8:
     frame_dig 9
-    // tests/artifacts/Arrays/uint64.py:135-136
+    // tests/artifacts/Arrays/uint64.py:153-154
     // # enumerate
     // for idx, value in uenumerate(arr):
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     frame_bury 3
-    intc_1 // 0
+    intc_2 // 0
     frame_bury 5
 
 test_iteration_for_header@9:
-    // tests/artifacts/Arrays/uint64.py:135-136
+    // tests/artifacts/Arrays/uint64.py:153-154
     // # enumerate
     // for idx, value in uenumerate(arr):
     frame_dig 5
@@ -1376,52 +1446,46 @@ test_iteration_for_header@9:
     frame_dig 5
     dup
     cover 2
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
-    // tests/artifacts/Arrays/uint64.py:137
+    // tests/artifacts/Arrays/uint64.py:155
     // assert value == idx, "incorrect array value"
     dig 1
     ==
     assert // incorrect array value
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 5
     b test_iteration_for_header@9
 
 test_iteration_after_for@12:
     frame_dig 9
-    // tests/artifacts/Arrays/uint64.py:139-140
+    // tests/artifacts/Arrays/uint64.py:157-158
     // # reverse
     // for value in reversed(arr):
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     frame_bury 8
 
 test_iteration_for_header@13:
-    // tests/artifacts/Arrays/uint64.py:139-140
+    // tests/artifacts/Arrays/uint64.py:157-158
     // # reverse
     // for value in reversed(arr):
     frame_dig 8
     bz test_iteration_after_for@16
     frame_dig 8
-    intc_2 // 1
+    intc_0 // 1
     -
     dup
     frame_bury 8
     frame_dig 9
     swap
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
-    // tests/artifacts/Arrays/uint64.py:141
+    // tests/artifacts/Arrays/uint64.py:159
     // assert value <= last, "array is not sorted"
     dup
     frame_dig 7
@@ -1431,104 +1495,102 @@ test_iteration_for_header@13:
     b test_iteration_for_header@13
 
 test_iteration_after_for@16:
-    // tests/artifacts/Arrays/uint64.py:144
+    // tests/artifacts/Arrays/uint64.py:162
     // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
     pushbytes 0x0000
     frame_bury 0
-    // tests/artifacts/Arrays/uint64.py:145
-    // native_arr = Array[arc4.UInt64]()
+    // tests/artifacts/Arrays/uint64.py:142
+    // arr = ReferenceArray[UInt64]()
     bytec_0 // 0x
     frame_bury 1
-    // tests/artifacts/Arrays/uint64.py:146
+    // tests/artifacts/Arrays/uint64.py:164
     // for i in urange(5):
-    intc_1 // 0
+    intc_2 // 0
     frame_bury 4
 
 test_iteration_for_header@17:
-    // tests/artifacts/Arrays/uint64.py:146
+    // tests/artifacts/Arrays/uint64.py:164
     // for i in urange(5):
     frame_dig 4
     intc_3 // 5
     <
     bz test_iteration_after_for@20
-    // tests/artifacts/Arrays/uint64.py:147
+    // tests/artifacts/Arrays/uint64.py:165
     // arc4_arr.append(arc4.UInt64(i))
-    frame_dig 0
-    extract 2 0
     frame_dig 4
     dup
-    cover 2
     itob
-    swap
-    dig 1
-    concat
+    frame_dig 0
     dup
-    len
-    intc_0 // 8
-    /
+    cover 2
+    dig 1
+    concat // on error: max array length exceeded
+    uncover 2
+    intc_2 // 0
+    extract_uint16
+    intc_0 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 0
     frame_dig 1
-    // tests/artifacts/Arrays/uint64.py:148
+    // tests/artifacts/Arrays/uint64.py:166
     // native_arr.append(arc4.UInt64(i))
     swap
     concat // on error: max array length exceeded
     frame_bury 1
-    // tests/artifacts/Arrays/uint64.py:146
+    // tests/artifacts/Arrays/uint64.py:164
     // for i in urange(5):
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 4
     b test_iteration_for_header@17
 
 test_iteration_after_for@20:
-    // tests/artifacts/Arrays/uint64.py:149
+    // tests/artifacts/Arrays/uint64.py:167
     // combined_arr = arc4_arr + native_arr
     frame_dig 0
-    extract 2 0
     frame_dig 1
-    concat
+    concat // on error: max array length exceeded
     dup
+    extract 2 0
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     itob
     extract 6 2
-    swap
-    concat
-    // tests/artifacts/Arrays/uint64.py:150
+    replace2 0
+    // tests/artifacts/Arrays/uint64.py:168
     // assert combined_arr.length == 10
     dup
-    intc_1 // 0
+    intc_2 // 0
     extract_uint16
     pushint 10 // 10
     ==
     assert
-    // tests/artifacts/Arrays/uint64.py:151
+    // tests/artifacts/Arrays/uint64.py:169
     // assert combined_arr[0] == 0
     dup
     extract 2 8
     bytec_2 // 0x0000000000000000
     b==
     assert
-    // tests/artifacts/Arrays/uint64.py:152
+    // tests/artifacts/Arrays/uint64.py:170
     // assert combined_arr[4] == 4
     dup
     extract 34 8
     bytec_3 // 0x0000000000000004
     b==
     assert
-    // tests/artifacts/Arrays/uint64.py:153
+    // tests/artifacts/Arrays/uint64.py:171
     // assert combined_arr[5] == 0
     dup
     extract 42 8
     bytec_2 // 0x0000000000000000
     b==
     assert
-    // tests/artifacts/Arrays/uint64.py:154
+    // tests/artifacts/Arrays/uint64.py:172
     // assert combined_arr[9] == 4
     extract 74 8
     bytec_3 // 0x0000000000000004
@@ -1539,90 +1601,90 @@ test_iteration_after_for@20:
 
 // tests.artifacts.Arrays.uint64.Contract.test_quicksort() -> void:
 test_quicksort:
-    // tests/artifacts/Arrays/uint64.py:156-157
+    // tests/artifacts/Arrays/uint64.py:174-175
     // @arc4.abimethod()
     // def test_quicksort(self) -> None:
     proto 0 0
     bytec_0 // ""
     dupn 2
-    // tests/artifacts/Arrays/uint64.py:158-159
+    // tests/artifacts/Arrays/uint64.py:176-177
     // # create pseudo random array from sender address
-    // rnd = Array[UInt64]()
+    // rnd = ReferenceArray[UInt64]()
     callsub _puya_lib.mem.new_slot
     dup
     bytec_0 // 0x
     stores
-    // tests/artifacts/Arrays/uint64.py:160
+    // tests/artifacts/Arrays/uint64.py:178
     // for b in Txn.sender.bytes:
     txn Sender
-    intc_1 // 0
+    intc_2 // 0
 
 test_quicksort_for_header@1:
-    // tests/artifacts/Arrays/uint64.py:160
+    // tests/artifacts/Arrays/uint64.py:178
     // for b in Txn.sender.bytes:
     frame_dig 5
     pushint 32 // 32
     <
     bz test_quicksort_after_for@4
-    // tests/artifacts/Arrays/uint64.py:161
+    // tests/artifacts/Arrays/uint64.py:179
     // rnd.append(op.btoi(b))
     frame_dig 4
     frame_dig 5
     dup
     cover 2
     getbyte
-    itob
     frame_dig 3
     dup
     cover 2
     loads
     swap
+    itob
     concat // on error: max array length exceeded
     stores
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 5
     b test_quicksort_for_header@1
 
 test_quicksort_after_for@4:
-    // tests/artifacts/Arrays/uint64.py:162
+    // tests/artifacts/Arrays/uint64.py:180
     // assert rnd.length == 32, "expected array of length 32"
     frame_dig 3
     dup
     loads
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     dup
     pushint 32 // 32
     ==
     assert // expected array of length 32
-    // tests/artifacts/Arrays/uint64.py:164-165
+    // tests/artifacts/Arrays/uint64.py:182-183
     // # sort the array
     // quicksort_window(rnd, UInt64(0), rnd.length - 1)
-    intc_2 // 1
+    intc_0 // 1
     -
     dig 1
-    intc_1 // 0
+    intc_2 // 0
     uncover 2
     callsub quicksort_window
-    // tests/artifacts/Arrays/uint64.py:167-168
+    // tests/artifacts/Arrays/uint64.py:185-186
     // # array should now be in ascending order
     // last = UInt64(0)
-    intc_1 // 0
+    intc_2 // 0
     frame_bury 2
-    // tests/artifacts/Arrays/uint64.py:169
+    // tests/artifacts/Arrays/uint64.py:187
     // for value in rnd:
     loads
     len
-    intc_0 // 8
+    intc_1 // 8
     /
     frame_bury 0
-    intc_1 // 0
+    intc_2 // 0
     frame_bury 1
 
 test_quicksort_for_header@5:
-    // tests/artifacts/Arrays/uint64.py:169
+    // tests/artifacts/Arrays/uint64.py:187
     // for value in rnd:
     frame_dig 1
     frame_dig 0
@@ -1633,20 +1695,17 @@ test_quicksort_for_header@5:
     frame_dig 1
     dup
     cover 2
-    intc_0 // 8
+    intc_1 // 8
     *
-    intc_0 // 8
-    extract3
-    intc_1 // 0
     extract_uint64
-    // tests/artifacts/Arrays/uint64.py:170
+    // tests/artifacts/Arrays/uint64.py:188
     // assert value >= last, "array is not sorted"
     dup
     frame_dig 2
     >=
     assert // array is not sorted
     swap
-    intc_2 // 1
+    intc_0 // 1
     +
     frame_bury 1
     frame_bury 2
@@ -1656,6 +1715,61 @@ test_quicksort_after_for@8:
     retsub
 
 
+// tests.artifacts.Arrays.uint64.Contract.test_unobserved_write() -> void:
+test_unobserved_write:
+    // tests/artifacts/Arrays/uint64.py:193
+    // arr = create_array()
+    callsub create_array
+    // tests/artifacts/Arrays/uint64.py:194
+    // last = arr.length - 1
+    dup
+    loads
+    dup
+    len
+    intc_1 // 8
+    /
+    intc_0 // 1
+    -
+    // tests/artifacts/Arrays/uint64.py:195
+    // arr[last] = UInt64(0)  # write
+    intc_2 // 0
+    itob
+    swap
+    intc_1 // 8
+    *
+    uncover 2
+    dig 1
+    uncover 3
+    replace3
+    dig 2
+    swap
+    stores
+    // tests/artifacts/Arrays/uint64.py:196
+    // assert_last_is_zero(arr)
+    dig 1
+    callsub assert_last_is_zero
+    // tests/artifacts/Arrays/uint64.py:197
+    // arr[last] = UInt64(1)  # write
+    intc_0 // 1
+    itob
+    dig 2
+    loads
+    dig 2
+    uncover 2
+    replace3
+    uncover 2
+    dig 1
+    stores
+    // tests/artifacts/Arrays/uint64.py:198
+    // assert arr[last] == 1
+    swap
+    extract_uint64
+    intc_0 // 1
+    ==
+    assert
+    retsub
+
+
 // _puya_lib.mem.new_slot() -> uint64:
 _puya_lib.mem.new_slot:
     load 0
@@ -1664,7 +1778,7 @@ _puya_lib.mem.new_slot:
     pushint 256 // 256
     dig 2
     -
-    intc_1 // 0
+    intc_2 // 0
     setbit // on error: no available slots
     store 0
     retsub
diff --git a/tests/artifacts/Arrays/data/Contract.arc32.json b/tests/artifacts/Arrays/data/Contract.arc32.json
index 4215fc0e..0493e55e 100644
--- a/tests/artifacts/Arrays/data/Contract.arc32.json
+++ b/tests/artifacts/Arrays/data/Contract.arc32.json
@@ -35,6 +35,11 @@
                 "no_op": "CALL"
             }
         },
+        "test_array_assignment_maximum_cursage()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
         "test_allocations(uint64)void": {
             "call_config": {
                 "no_op": "CALL"
@@ -49,10 +54,15 @@
             "call_config": {
                 "no_op": "CALL"
             }
+        },
+        "test_unobserved_write()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 8 0 1 5 512
    bytecblock 0x 0x000000000000000100000000000000020000000000000003 0x0000000000000000 0x0000000000000004
    pushbytes 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    store 0
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@15
    pushbytess 0xa33be873 0xe0c378e9 0x366f509d 0x58351a50 0xfa99e984 0xa20e440f 0x179ac3f9 0xf17f6f0a 0x845e1b4e 0x7621cfd1 // method "test_array()void", method "test_array_extend()void", method "test_array_multiple_append()void", method "overhead()void", method "test_array_too_long()void", method "test_array_copy_and_extend()void", method "test_array_evaluation_order()void", method "test_allocations(uint64)void", method "test_iteration()void", method "test_quicksort()void"
    txna ApplicationArgs 0
    match main_test_array_route@3 main_test_array_extend_route@4 main_test_array_multiple_append_route@5 main_overhead_route@6 main_test_array_too_long_route@7 main_test_array_copy_and_extend_route@8 main_test_array_evaluation_order_route@9 main_test_allocations_route@10 main_test_iteration_route@11 main_test_quicksort_route@12

main_after_if_else@19:
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    intc_1 // 0
    return

main_test_quicksort_route@12:
    // tests/artifacts/Arrays/uint64.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_quicksort
    intc_2 // 1
    return

main_test_iteration_route@11:
    // tests/artifacts/Arrays/uint64.py:122
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_iteration
    intc_2 // 1
    return

main_test_allocations_route@10:
    // tests/artifacts/Arrays/uint64.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/uint64.py:116
    // @arc4.abimethod()
    callsub test_allocations
    intc_2 // 1
    return

main_test_array_evaluation_order_route@9:
    // tests/artifacts/Arrays/uint64.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_evaluation_order
    intc_2 // 1
    return

main_test_array_copy_and_extend_route@8:
    // tests/artifacts/Arrays/uint64.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_copy_and_extend
    intc_2 // 1
    return

main_test_array_too_long_route@7:
    // tests/artifacts/Arrays/uint64.py:66
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_too_long
    intc_2 // 1
    return

main_overhead_route@6:
    // tests/artifacts/Arrays/uint64.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    intc_2 // 1
    return

main_test_array_multiple_append_route@5:
    // tests/artifacts/Arrays/uint64.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_multiple_append
    intc_2 // 1
    return

main_test_array_extend_route@4:
    // tests/artifacts/Arrays/uint64.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_extend
    intc_2 // 1
    return

main_test_array_route@3:
    // tests/artifacts/Arrays/uint64.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array
    intc_2 // 1
    return

main_bare_routing@15:
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@19
    txn ApplicationID
    !
    assert // can only call when creating
    intc_2 // 1
    return


// tests.artifacts.Arrays.uint64.quicksort_window(arr: uint64, window_left: uint64, window_right: uint64) -> void:
quicksort_window:
    // tests/artifacts/Arrays/uint64.py:174-175
    // @subroutine
    // def quicksort_window(arr: Array[UInt64], window_left: UInt64, window_right: UInt64) -> None:
    proto 3 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:178
    // pivot = arr[(window_left + window_right) // 2]
    frame_dig -2
    frame_dig -1
    +
    pushint 2 // 2
    /
    frame_dig -3
    loads
    swap
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    frame_dig -1
    frame_dig -2

quicksort_window_while_top@3:
    // tests/artifacts/Arrays/uint64.py:182-183
    // # move left of window towards pivot
    // while arr[left] < pivot:
    frame_dig -3
    loads
    frame_dig 5
    intc_0 // 8
    *
    dup
    frame_bury 0
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    frame_dig 3
    <
    bz quicksort_window_while_top@6
    // tests/artifacts/Arrays/uint64.py:184
    // left += 1
    frame_dig 5
    intc_2 // 1
    +
    frame_bury 5
    b quicksort_window_while_top@3

quicksort_window_while_top@6:
    // tests/artifacts/Arrays/uint64.py:185-186
    // # move right of window towards pivot
    // while pivot < arr[right]:
    frame_dig -3
    loads
    frame_dig 4
    intc_0 // 8
    *
    dup
    frame_bury 1
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    frame_dig 3
    >
    bz quicksort_window_after_while@10
    // tests/artifacts/Arrays/uint64.py:187-188
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:190
    // right -= 1
    frame_dig 4
    intc_2 // 1
    -
    frame_bury 4
    b quicksort_window_while_top@6

quicksort_window_after_while@22:
    // tests/artifacts/Arrays/uint64.py:218-219
    // # sort left half of window
    // if window_left < right:
    frame_dig -2
    frame_dig 4
    <
    bz quicksort_window_after_if_else@24
    // tests/artifacts/Arrays/uint64.py:220
    // quicksort_window(arr, window_left, right)
    frame_dig -3
    frame_dig -2
    frame_dig 4
    callsub quicksort_window

quicksort_window_after_if_else@24:
    // tests/artifacts/Arrays/uint64.py:221-222
    // # sort right half of window
    // if left < window_right:
    frame_dig 5
    frame_dig -1
    <
    bz quicksort_window_after_if_else@26
    // tests/artifacts/Arrays/uint64.py:223
    // quicksort_window(arr, left, window_right)
    frame_dig -3
    frame_dig 5
    frame_dig -1
    callsub quicksort_window

quicksort_window_after_if_else@26:
    retsub

quicksort_window_after_while@10:
    // tests/artifacts/Arrays/uint64.py:192-193
    // # if window isn't empty then swap values and move window in
    // if left < right:
    frame_dig 5
    frame_dig 4
    <
    bz quicksort_window_after_if_else@16
    // tests/artifacts/Arrays/uint64.py:194
    // arr[left], arr[right] = arr[right], arr[left]
    frame_dig -3
    loads
    dup
    frame_dig 1
    dup
    cover 3
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    dig 1
    frame_dig 0
    dup
    cover 4
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    swap
    itob
    uncover 2
    uncover 3
    uncover 2
    replace3
    swap
    itob
    swap
    cover 2
    replace3
    frame_dig -3
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:195
    // left += 1
    frame_dig 5
    intc_2 // 1
    +
    frame_bury 5
    // tests/artifacts/Arrays/uint64.py:196-197
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:199
    // right -= 1
    frame_dig 4
    intc_2 // 1
    -
    dup
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:200-201
    // # explicit continue to avoid hitting outer break
    // if left <= right:
    frame_dig 5
    >=
    bnz quicksort_window_while_top@3
    b quicksort_window_after_while@22

quicksort_window_after_if_else@16:
    // tests/artifacts/Arrays/uint64.py:206-207
    // # if window is just one item, don't bother swapping, but still adjust window
    // if left == right:
    frame_dig 5
    frame_dig 4
    ==
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:208
    // left += 1
    frame_dig 5
    intc_2 // 1
    +
    frame_bury 5
    frame_dig 4
    dup
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:209-210
    // # don't decrement right if it would go negative
    // if right:
    bz quicksort_window_after_if_else@19
    // tests/artifacts/Arrays/uint64.py:211
    // right -= 1
    frame_dig 4
    intc_2 // 1
    -
    frame_bury 2

quicksort_window_after_if_else@19:
    frame_dig 2
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:212-214
    // # loop always ends in this scenario
    // # and an explict break consumes fewer ops
    // break
    b quicksort_window_after_while@22


// tests.artifacts.Arrays.uint64.add_x(arr: uint64, x: uint64) -> void:
add_x:
    // tests/artifacts/Arrays/uint64.py:233-234
    // @subroutine
    // def add_x(arr: Array[UInt64], x: UInt64) -> None:
    proto 2 0
    // tests/artifacts/Arrays/uint64.py:235
    // for i in urange(x):
    intc_1 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/uint64.py:235
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/uint64.py:236
    // arr.append(i)
    frame_dig 0
    dup
    itob
    frame_dig -2
    loads
    swap
    concat // on error: max array length exceeded
    frame_dig -2
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:235
    // for i in urange(x):
    intc_2 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.append_length_and_return(arr: uint64) -> uint64:
append_length_and_return:
    // tests/artifacts/Arrays/uint64.py:247-248
    // @subroutine
    // def append_length_and_return(arr: Array[UInt64]) -> Array[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/uint64.py:249
    // arr.append(arr.length)
    frame_dig -1
    loads
    dup
    len
    intc_0 // 8
    /
    itob
    concat // on error: max array length exceeded
    frame_dig -1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:250
    // return arr
    frame_dig -1
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array() -> void:
test_array:
    // tests/artifacts/Arrays/uint64.py:5-6
    // @arc4.abimethod()
    // def test_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:7
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    // tests/artifacts/Arrays/uint64.py:10
    // arr.append(UInt64(42))
    pushint 42 // 42
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:14
    // add_x(arr, UInt64(5))
    dup
    intc_3 // 5
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:15
    // assert arr.length == 6
    loads
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:16
    // assert arr[-1] == 4
    intc_2 // 1
    -
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:18
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 4 // 4
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    intc_1 // 0

test_array_for_header@2:
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    frame_dig 2
    // tests/artifacts/Arrays/uint64.py:18
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 3 // 3
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    <
    bz test_array_after_for@4
    // tests/artifacts/Arrays/uint64.py:242
    // popped = arr.pop()
    frame_dig 0
    dup
    loads
    dup
    len
    intc_0 // 8
    -
    dup
    intc_0 // 8
    /
    dig 2
    intc_1 // 0
    uncover 3
    extract3
    swap
    intc_0 // 8
    *
    uncover 2
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    cover 2
    stores
    // tests/artifacts/Arrays/uint64.py:243
    // assert popped == expected
    frame_dig 1
    dup
    cover 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:244
    // expected -= 1
    intc_2 // 1
    -
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    frame_dig 2
    intc_2 // 1
    +
    frame_bury 2
    b test_array_for_header@2

test_array_after_for@4:
    // tests/artifacts/Arrays/uint64.py:19
    // assert arr.length == 3
    frame_dig 0
    dup
    loads
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:20
    // assert arr[-1] == 1
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:22
    // arr.append(UInt64(43))
    pushint 43 // 43
    itob
    concat // on error: max array length exceeded
    dup2
    stores
    // tests/artifacts/Arrays/uint64.py:23
    // assert arr.length == 4
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:24
    // assert arr[-1] == 43
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 43 // 43
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:25
    // assert arr[0] == 42
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:27
    // add_x(arr, UInt64(10))
    dup
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:28
    // assert arr.length == 14
    dup
    loads
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:29
    // assert arr[-1] == 9
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:31
    // arr.append(UInt64(44))
    pushint 44 // 44
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:32
    // assert arr.length == 15
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:33
    // assert arr[-1] == 44
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:228
    // arr.append(UInt64(99))
    pushint 99 // 99
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:229
    // arr2.append(UInt64(100))
    pushint 100 // 100
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:35
    // return_ref(arr, arr)[0] += 2
    dup
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 2 // 2
    +
    itob
    replace2 0
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:36
    // assert arr.length == 17
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 17 // 17
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:37
    // assert arr[0] == 44
    dig 1
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:38
    // assert arr[-2] == 99
    dup
    pushint 2 // 2
    -
    intc_0 // 8
    *
    dig 2
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 99 // 99
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:39
    // assert arr[-1] == 100
    intc_2 // 1
    -
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 100 // 100
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_extend() -> void:
test_array_extend:
    // tests/artifacts/Arrays/uint64.py:43
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:44
    // add_x(arr, UInt64(1))
    dup
    intc_2 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:48
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/uint64.py:50
    // arr.extend(arr2)
    dup
    loads
    // tests/artifacts/Arrays/uint64.py:48
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/uint64.py:50
    // arr.extend(arr2)
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:51
    // assert arr.length == 4
    len
    intc_0 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_multiple_append() -> void:
test_array_multiple_append:
    // tests/artifacts/Arrays/uint64.py:55
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:56
    // add_x(arr, UInt64(1))
    dup
    intc_2 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:57
    // arr.append(UInt64(1))
    intc_2 // 1
    itob
    dig 1
    loads
    swap
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:58
    // arr.append(UInt64(2))
    pushint 2 // 2
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:59
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:60
    // assert arr.length == 4
    len
    intc_0 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_too_long() -> void:
test_array_too_long:
    // tests/artifacts/Arrays/uint64.py:66-67
    // @arc4.abimethod()
    // def test_array_too_long(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:68
    // array = Array[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:69
    // for i in urange(512):
    intc_1 // 0

test_array_too_long_for_header@1:
    // tests/artifacts/Arrays/uint64.py:69
    // for i in urange(512):
    frame_dig 1
    intc 4 // 512
    <
    bz test_array_too_long_after_for@4
    // tests/artifacts/Arrays/uint64.py:70
    // array.append(i)
    frame_dig 1
    dup
    itob
    frame_dig 0
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:69
    // for i in urange(512):
    intc_2 // 1
    +
    frame_bury 1
    b test_array_too_long_for_header@1

test_array_too_long_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:71
    // assert array.length == 512, "array is expected length"
    dup
    len
    intc_0 // 8
    /
    intc 4 // 512
    ==
    assert // array is expected length
    // tests/artifacts/Arrays/uint64.py:73
    // array.append(UInt64(512))  # this will fail
    intc 4 // 512
    itob
    concat // on error: max array length exceeded
    pop
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_copy_and_extend() -> void:
test_array_copy_and_extend:
    // tests/artifacts/Arrays/uint64.py:75-76
    // @arc4.abimethod()
    // def test_array_copy_and_extend(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:77
    // array = Array[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(5):
    intc_1 // 0

test_array_copy_and_extend_for_header@1:
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(5):
    frame_dig 1
    intc_3 // 5
    <
    bz test_array_copy_and_extend_after_for@4
    // tests/artifacts/Arrays/uint64.py:79
    // array.append(i)
    frame_dig 1
    dup
    itob
    frame_dig 0
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(5):
    intc_2 // 1
    +
    frame_bury 1
    b test_array_copy_and_extend_for_header@1

test_array_copy_and_extend_after_for@4:
    frame_dig 0
    dup
    // tests/artifacts/Arrays/uint64.py:82
    // array.append(UInt64(5))
    intc_3 // 5
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:83
    // assert array.length == 6
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:84
    // assert array[-1] == 5, "expected 5"
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 5
    dig 1
    // tests/artifacts/Arrays/uint64.py:86
    // assert array2.length == 5
    dup
    len
    intc_0 // 8
    /
    dup
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:87
    // assert array2[-1] == 4, "expected 4"
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:89
    // array.extend(array2)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:90
    // assert array.length == 11
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 11 // 11
    ==
    assert
    uncover 2
    // tests/artifacts/Arrays/uint64.py:91
    // assert array2.length == 5
    len
    intc_0 // 8
    /
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:92
    // assert array[-1] == 4, "expected 4"
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:93
    // assert array[4] == 4, "expected 4"
    dup
    extract 32 8
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:94
    // assert array[5] == 5, "expected 4"
    dup
    extract 40 8
    intc_1 // 0
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:95
    // assert array[6] == 0, "expected 4"
    extract 48 8
    intc_1 // 0
    extract_uint64
    !
    assert // expected 4
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_evaluation_order() -> void:
test_array_evaluation_order:
    // tests/artifacts/Arrays/uint64.py:99
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    // tests/artifacts/Arrays/uint64.py:100
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:101
    // append_length_and_return(arr).extend(append_length_and_return(arr))
    dup
    callsub append_length_and_return
    dig 1
    callsub append_length_and_return
    loads
    dig 1
    loads
    swap
    concat // on error: max array length exceeded
    stores
    // tests/artifacts/Arrays/uint64.py:102
    // assert arr.length == 6
    dup
    loads
    dup
    len
    intc_0 // 8
    /
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:103
    // assert arr[0] == 3
    dup
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:104
    // assert arr[1] == 1
    dup
    extract 8 8
    intc_1 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:105
    // assert arr[2] == 2
    dup
    extract 16 8
    intc_1 // 0
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:106
    // assert arr[3] == 3
    dup
    extract 24 8
    intc_1 // 0
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:107
    // assert arr[4] == 1
    dup
    extract 32 8
    intc_1 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:108
    // assert arr[5] == 2
    extract 40 8
    intc_1 // 0
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:110
    // arr[append_length_and_return(arr)[0]] = append_length_and_return(arr)[-1]
    dup
    callsub append_length_and_return
    loads
    dup
    len
    intc_0 // 8
    /
    intc_2 // 1
    -
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    dig 1
    callsub append_length_and_return
    loads
    extract 0 8
    intc_1 // 0
    extract_uint64
    dig 2
    loads
    swap
    intc_0 // 8
    *
    uncover 2
    itob
    replace3
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:111
    // assert arr.length == 8
    dup
    len
    intc_0 // 8
    /
    intc_0 // 8
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:112
    // assert arr[6] == 6
    dup
    extract 48 8
    intc_1 // 0
    extract_uint64
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:113
    // assert arr[7] == 7
    dup
    extract 56 8
    intc_1 // 0
    extract_uint64
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:114
    // assert arr[3] == 6
    extract 24 8
    intc_1 // 0
    extract_uint64
    pushint 6 // 6
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_allocations(num: uint64) -> void:
test_allocations:
    // tests/artifacts/Arrays/uint64.py:116-117
    // @arc4.abimethod()
    // def test_allocations(self, num: UInt64) -> None:
    proto 1 0
    // tests/artifacts/Arrays/uint64.py:118
    // for _i in urange(num):
    intc_1 // 0

test_allocations_for_header@1:
    // tests/artifacts/Arrays/uint64.py:118
    // for _i in urange(num):
    frame_dig 0
    frame_dig -1
    <
    bz test_allocations_after_for@4
    // tests/artifacts/Arrays/uint64.py:119
    // alloc_test = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:120
    // add_x(alloc_test, UInt64(1))
    intc_2 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:118
    // for _i in urange(num):
    frame_dig 0
    intc_2 // 1
    +
    frame_bury 0
    b test_allocations_for_header@1

test_allocations_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_iteration() -> void:
test_iteration:
    // tests/artifacts/Arrays/uint64.py:122-123
    // @arc4.abimethod()
    // def test_iteration(self) -> None:
    proto 0 0
    intc_1 // 0
    dup
    bytec_0 // ""
    // tests/artifacts/Arrays/uint64.py:124
    // arr = Array[UInt64]()
    dupn 7
    // tests/artifacts/Arrays/uint64.py:125
    // for val in urange(5):
    intc_1 // 0

test_iteration_for_header@1:
    // tests/artifacts/Arrays/uint64.py:125
    // for val in urange(5):
    frame_dig 10
    intc_3 // 5
    <
    bz test_iteration_after_for@4
    // tests/artifacts/Arrays/uint64.py:126
    // arr.append(val)
    frame_dig 10
    dup
    itob
    frame_dig 9
    swap
    concat // on error: max array length exceeded
    frame_bury 9
    // tests/artifacts/Arrays/uint64.py:125
    // for val in urange(5):
    intc_2 // 1
    +
    frame_bury 10
    b test_iteration_for_header@1

test_iteration_after_for@4:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:127
    // assert arr.length == 5, "expected array of length 5"
    len
    intc_0 // 8
    /
    dup
    frame_bury 2
    intc_3 // 5
    ==
    assert // expected array of length 5
    // tests/artifacts/Arrays/uint64.py:129-130
    // # iterate
    // last = UInt64(0)
    intc_1 // 0
    frame_bury 7
    intc_1 // 0
    frame_bury 6

test_iteration_for_header@5:
    // tests/artifacts/Arrays/uint64.py:131
    // for value in arr:
    frame_dig 6
    frame_dig 2
    <
    bz test_iteration_after_for@8
    frame_dig 9
    frame_dig 6
    dup
    cover 2
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:132
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 7
    >=
    assert // array is not sorted
    swap
    intc_2 // 1
    +
    frame_bury 6
    frame_bury 7
    b test_iteration_for_header@5

test_iteration_after_for@8:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:135-136
    // # enumerate
    // for idx, value in uenumerate(arr):
    len
    intc_0 // 8
    /
    frame_bury 3
    intc_1 // 0
    frame_bury 5

test_iteration_for_header@9:
    // tests/artifacts/Arrays/uint64.py:135-136
    // # enumerate
    // for idx, value in uenumerate(arr):
    frame_dig 5
    frame_dig 3
    <
    bz test_iteration_after_for@12
    frame_dig 9
    frame_dig 5
    dup
    cover 2
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:137
    // assert value == idx, "incorrect array value"
    dig 1
    ==
    assert // incorrect array value
    intc_2 // 1
    +
    frame_bury 5
    b test_iteration_for_header@9

test_iteration_after_for@12:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:139-140
    // # reverse
    // for value in reversed(arr):
    len
    intc_0 // 8
    /
    frame_bury 8

test_iteration_for_header@13:
    // tests/artifacts/Arrays/uint64.py:139-140
    // # reverse
    // for value in reversed(arr):
    frame_dig 8
    bz test_iteration_after_for@16
    frame_dig 8
    intc_2 // 1
    -
    dup
    frame_bury 8
    frame_dig 9
    swap
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:141
    // assert value <= last, "array is not sorted"
    dup
    frame_dig 7
    <=
    assert // array is not sorted
    frame_bury 7
    b test_iteration_for_header@13

test_iteration_after_for@16:
    // tests/artifacts/Arrays/uint64.py:144
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    pushbytes 0x0000
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:145
    // native_arr = Array[arc4.UInt64]()
    bytec_0 // 0x
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:146
    // for i in urange(5):
    intc_1 // 0
    frame_bury 4

test_iteration_for_header@17:
    // tests/artifacts/Arrays/uint64.py:146
    // for i in urange(5):
    frame_dig 4
    intc_3 // 5
    <
    bz test_iteration_after_for@20
    // tests/artifacts/Arrays/uint64.py:147
    // arc4_arr.append(arc4.UInt64(i))
    frame_dig 0
    extract 2 0
    frame_dig 4
    dup
    cover 2
    itob
    swap
    dig 1
    concat
    dup
    len
    intc_0 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    frame_dig 1
    // tests/artifacts/Arrays/uint64.py:148
    // native_arr.append(arc4.UInt64(i))
    swap
    concat // on error: max array length exceeded
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:146
    // for i in urange(5):
    intc_2 // 1
    +
    frame_bury 4
    b test_iteration_for_header@17

test_iteration_after_for@20:
    // tests/artifacts/Arrays/uint64.py:149
    // combined_arr = arc4_arr + native_arr
    frame_dig 0
    extract 2 0
    frame_dig 1
    concat
    dup
    len
    intc_0 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/uint64.py:150
    // assert combined_arr.length == 10
    dup
    intc_1 // 0
    extract_uint16
    pushint 10 // 10
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:151
    // assert combined_arr[0] == 0
    dup
    extract 2 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:152
    // assert combined_arr[4] == 4
    dup
    extract 34 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:153
    // assert combined_arr[5] == 0
    dup
    extract 42 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:154
    // assert combined_arr[9] == 4
    extract 74 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_quicksort() -> void:
test_quicksort:
    // tests/artifacts/Arrays/uint64.py:156-157
    // @arc4.abimethod()
    // def test_quicksort(self) -> None:
    proto 0 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:158-159
    // # create pseudo random array from sender address
    // rnd = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:160
    // for b in Txn.sender.bytes:
    txn Sender
    intc_1 // 0

test_quicksort_for_header@1:
    // tests/artifacts/Arrays/uint64.py:160
    // for b in Txn.sender.bytes:
    frame_dig 5
    pushint 32 // 32
    <
    bz test_quicksort_after_for@4
    // tests/artifacts/Arrays/uint64.py:161
    // rnd.append(op.btoi(b))
    frame_dig 4
    frame_dig 5
    dup
    cover 2
    getbyte
    itob
    frame_dig 3
    dup
    cover 2
    loads
    swap
    concat // on error: max array length exceeded
    stores
    intc_2 // 1
    +
    frame_bury 5
    b test_quicksort_for_header@1

test_quicksort_after_for@4:
    // tests/artifacts/Arrays/uint64.py:162
    // assert rnd.length == 32, "expected array of length 32"
    frame_dig 3
    dup
    loads
    len
    intc_0 // 8
    /
    dup
    pushint 32 // 32
    ==
    assert // expected array of length 32
    // tests/artifacts/Arrays/uint64.py:164-165
    // # sort the array
    // quicksort_window(rnd, UInt64(0), rnd.length - 1)
    intc_2 // 1
    -
    dig 1
    intc_1 // 0
    uncover 2
    callsub quicksort_window
    // tests/artifacts/Arrays/uint64.py:167-168
    // # array should now be in ascending order
    // last = UInt64(0)
    intc_1 // 0
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:169
    // for value in rnd:
    loads
    len
    intc_0 // 8
    /
    frame_bury 0
    intc_1 // 0
    frame_bury 1

test_quicksort_for_header@5:
    // tests/artifacts/Arrays/uint64.py:169
    // for value in rnd:
    frame_dig 1
    frame_dig 0
    <
    bz test_quicksort_after_for@8
    frame_dig 3
    loads
    frame_dig 1
    dup
    cover 2
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:170
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 2
    >=
    assert // array is not sorted
    swap
    intc_2 // 1
    +
    frame_bury 1
    frame_bury 2
    b test_quicksort_for_header@5

test_quicksort_after_for@8:
    retsub


// _puya_lib.mem.new_slot() -> uint64:
_puya_lib.mem.new_slot:
    load 0
    bitlen
    load 0
    pushint 256 // 256
    dig 2
    -
    intc_1 // 0
    setbit // on error: no available slots
    store 0
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 0 5 512
    bytecblock 0x 0x000000000000000100000000000000020000000000000003 0x0000000000000000 0x0000000000000004
    pushbytes 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    store 0
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@17
    pushbytess 0xa33be873 0xe0c378e9 0x366f509d 0x58351a50 0xfa99e984 0xa20e440f 0x179ac3f9 0x45dcc836 0xf17f6f0a 0x845e1b4e 0x7621cfd1 0x5661a67c // method "test_array()void", method "test_array_extend()void", method "test_array_multiple_append()void", method "overhead()void", method "test_array_too_long()void", method "test_array_copy_and_extend()void", method "test_array_evaluation_order()void", method "test_array_assignment_maximum_cursage()void", method "test_allocations(uint64)void", method "test_iteration()void", method "test_quicksort()void", method "test_unobserved_write()void"
    txna ApplicationArgs 0
    match main_test_array_route@3 main_test_array_extend_route@4 main_test_array_multiple_append_route@5 main_overhead_route@6 main_test_array_too_long_route@7 main_test_array_copy_and_extend_route@8 main_test_array_evaluation_order_route@9 main_test_array_assignment_maximum_cursage_route@10 main_test_allocations_route@11 main_test_iteration_route@12 main_test_quicksort_route@13 main_test_unobserved_write_route@14

main_after_if_else@21:
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    intc_2 // 0
    return

main_test_unobserved_write_route@14:
    // tests/artifacts/Arrays/uint64.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_unobserved_write
    intc_0 // 1
    return

main_test_quicksort_route@13:
    // tests/artifacts/Arrays/uint64.py:174
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_quicksort
    intc_0 // 1
    return

main_test_iteration_route@12:
    // tests/artifacts/Arrays/uint64.py:140
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_iteration
    intc_0 // 1
    return

main_test_allocations_route@11:
    // tests/artifacts/Arrays/uint64.py:134
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/uint64.py:134
    // @arc4.abimethod()
    callsub test_allocations
    intc_0 // 1
    return

main_test_array_assignment_maximum_cursage_route@10:
    // tests/artifacts/Arrays/uint64.py:125
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_assignment_maximum_cursage
    intc_0 // 1
    return

main_test_array_evaluation_order_route@9:
    // tests/artifacts/Arrays/uint64.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_evaluation_order
    intc_0 // 1
    return

main_test_array_copy_and_extend_route@8:
    // tests/artifacts/Arrays/uint64.py:84
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_copy_and_extend
    intc_0 // 1
    return

main_test_array_too_long_route@7:
    // tests/artifacts/Arrays/uint64.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_too_long
    intc_0 // 1
    return

main_overhead_route@6:
    // tests/artifacts/Arrays/uint64.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    intc_0 // 1
    return

main_test_array_multiple_append_route@5:
    // tests/artifacts/Arrays/uint64.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_multiple_append
    intc_0 // 1
    return

main_test_array_extend_route@4:
    // tests/artifacts/Arrays/uint64.py:50
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_extend
    intc_0 // 1
    return

main_test_array_route@3:
    // tests/artifacts/Arrays/uint64.py:14
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array
    intc_0 // 1
    return

main_bare_routing@17:
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@21
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arrays.uint64.quicksort_window(arr: uint64, window_left: uint64, window_right: uint64) -> void:
quicksort_window:
    // tests/artifacts/Arrays/uint64.py:201-204
    // @subroutine
    // def quicksort_window(
    //     arr: ReferenceArray[UInt64], window_left: UInt64, window_right: UInt64
    // ) -> None:
    proto 3 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:207
    // pivot = arr[(window_left + window_right) // 2]
    frame_dig -2
    frame_dig -1
    +
    pushint 2 // 2
    /
    frame_dig -3
    loads
    swap
    intc_1 // 8
    *
    extract_uint64
    frame_dig -1
    frame_dig -2

quicksort_window_while_top@3:
    // tests/artifacts/Arrays/uint64.py:211-212
    // # move left of window towards pivot
    // while arr[left] < pivot:
    frame_dig -3
    loads
    frame_dig 5
    intc_1 // 8
    *
    dup
    frame_bury 0
    extract_uint64
    frame_dig 3
    <
    bz quicksort_window_while_top@6
    // tests/artifacts/Arrays/uint64.py:213
    // left += 1
    frame_dig 5
    intc_0 // 1
    +
    frame_bury 5
    b quicksort_window_while_top@3

quicksort_window_while_top@6:
    // tests/artifacts/Arrays/uint64.py:214-215
    // # move right of window towards pivot
    // while pivot < arr[right]:
    frame_dig -3
    loads
    frame_dig 4
    intc_1 // 8
    *
    dup
    frame_bury 1
    extract_uint64
    frame_dig 3
    >
    bz quicksort_window_after_while@10
    // tests/artifacts/Arrays/uint64.py:216-217
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:219
    // right -= 1
    frame_dig 4
    intc_0 // 1
    -
    frame_bury 4
    b quicksort_window_while_top@6

quicksort_window_after_while@22:
    // tests/artifacts/Arrays/uint64.py:247-248
    // # sort left half of window
    // if window_left < right:
    frame_dig -2
    frame_dig 4
    <
    bz quicksort_window_after_if_else@24
    // tests/artifacts/Arrays/uint64.py:249
    // quicksort_window(arr, window_left, right)
    frame_dig -3
    frame_dig -2
    frame_dig 4
    callsub quicksort_window

quicksort_window_after_if_else@24:
    // tests/artifacts/Arrays/uint64.py:250-251
    // # sort right half of window
    // if left < window_right:
    frame_dig 5
    frame_dig -1
    <
    bz quicksort_window_after_if_else@26
    // tests/artifacts/Arrays/uint64.py:252
    // quicksort_window(arr, left, window_right)
    frame_dig -3
    frame_dig 5
    frame_dig -1
    callsub quicksort_window

quicksort_window_after_if_else@26:
    retsub

quicksort_window_after_while@10:
    // tests/artifacts/Arrays/uint64.py:221-222
    // # if window isn't empty then swap values and move window in
    // if left < right:
    frame_dig 5
    frame_dig 4
    <
    bz quicksort_window_after_if_else@16
    // tests/artifacts/Arrays/uint64.py:223
    // arr[left], arr[right] = arr[right], arr[left]
    frame_dig -3
    loads
    dup
    frame_dig 1
    dup
    cover 3
    intc_1 // 8
    extract3 // on error: index access is out of bounds
    dig 1
    frame_dig 0
    dup
    cover 3
    intc_1 // 8
    extract3 // on error: index access is out of bounds
    cover 3
    replace3
    cover 2
    replace3
    frame_dig -3
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:224
    // left += 1
    frame_dig 5
    intc_0 // 1
    +
    frame_bury 5
    // tests/artifacts/Arrays/uint64.py:225-226
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:228
    // right -= 1
    frame_dig 4
    intc_0 // 1
    -
    dup
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:229-230
    // # explicit continue to avoid hitting outer break
    // if left <= right:
    frame_dig 5
    >=
    bnz quicksort_window_while_top@3
    b quicksort_window_after_while@22

quicksort_window_after_if_else@16:
    // tests/artifacts/Arrays/uint64.py:235-236
    // # if window is just one item, don't bother swapping, but still adjust window
    // if left == right:
    frame_dig 5
    frame_dig 4
    ==
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:237
    // left += 1
    frame_dig 5
    intc_0 // 1
    +
    frame_bury 5
    frame_dig 4
    dup
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:238-239
    // # don't decrement right if it would go negative
    // if right:
    bz quicksort_window_after_if_else@19
    // tests/artifacts/Arrays/uint64.py:240
    // right -= 1
    frame_dig 4
    intc_0 // 1
    -
    frame_bury 2

quicksort_window_after_if_else@19:
    frame_dig 2
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:241-243
    // # loop always ends in this scenario
    // # and an explict break consumes fewer ops
    // break
    b quicksort_window_after_while@22


// tests.artifacts.Arrays.uint64.create_array() -> uint64:
create_array:
    // tests/artifacts/Arrays/uint64.py:255-256
    // @subroutine(inline=False)
    // def create_array() -> ReferenceArray[UInt64]:
    proto 0 1
    // tests/artifacts/Arrays/uint64.py:257
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:258
    // for i in urange(5):
    intc_2 // 0

create_array_for_header@1:
    // tests/artifacts/Arrays/uint64.py:258
    // for i in urange(5):
    frame_dig 1
    intc_3 // 5
    <
    bz create_array_after_for@4
    // tests/artifacts/Arrays/uint64.py:259
    // arr.append(i)
    frame_dig 0
    dup
    loads
    frame_dig 1
    dup
    cover 3
    itob
    concat // on error: max array length exceeded
    stores
    // tests/artifacts/Arrays/uint64.py:258
    // for i in urange(5):
    intc_0 // 1
    +
    frame_bury 1
    b create_array_for_header@1

create_array_after_for@4:
    // tests/artifacts/Arrays/uint64.py:260
    // return arr
    retsub


// tests.artifacts.Arrays.uint64.assert_last_is_zero(arr: uint64) -> void:
assert_last_is_zero:
    // tests/artifacts/Arrays/uint64.py:263-264
    // @subroutine(inline=False)
    // def assert_last_is_zero(arr: ReferenceArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/uint64.py:265
    // assert arr[arr.length - 1] == 0
    frame_dig -1
    loads
    dup
    len
    intc_1 // 8
    /
    intc_0 // 1
    -
    intc_1 // 8
    *
    extract_uint64
    !
    assert
    retsub


// tests.artifacts.Arrays.uint64.add_x(arr: uint64, x: uint64) -> void:
add_x:
    // tests/artifacts/Arrays/uint64.py:277-278
    // @subroutine
    // def add_x(arr: ReferenceArray[UInt64], x: UInt64) -> None:
    proto 2 0
    // tests/artifacts/Arrays/uint64.py:279
    // for i in urange(x):
    intc_2 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/uint64.py:279
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/uint64.py:280
    // arr.append(i)
    frame_dig -2
    loads
    frame_dig 0
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_dig -2
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:279
    // for i in urange(x):
    intc_0 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.append_length_and_return(arr: uint64) -> uint64:
append_length_and_return:
    // tests/artifacts/Arrays/uint64.py:291-292
    // @subroutine
    // def append_length_and_return(arr: ReferenceArray[UInt64]) -> ReferenceArray[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/uint64.py:293
    // arr.append(arr.length)
    frame_dig -1
    loads
    dup
    len
    intc_1 // 8
    /
    itob
    concat // on error: max array length exceeded
    frame_dig -1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:294
    // return arr
    frame_dig -1
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array() -> void:
test_array:
    // tests/artifacts/Arrays/uint64.py:14-15
    // @arc4.abimethod()
    // def test_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:16
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    // tests/artifacts/Arrays/uint64.py:19
    // arr.append(UInt64(42))
    pushint 42 // 42
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:23
    // add_x(arr, UInt64(5))
    dup
    intc_3 // 5
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:24
    // assert arr.length == 6
    loads
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:25
    // assert arr[-1] == 4
    intc_0 // 1
    -
    intc_1 // 8
    *
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:27
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 4 // 4
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    intc_2 // 0

test_array_for_header@2:
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    frame_dig 2
    // tests/artifacts/Arrays/uint64.py:27
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 3 // 3
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    <
    bz test_array_after_for@4
    // tests/artifacts/Arrays/uint64.py:286
    // popped = arr.pop()
    frame_dig 0
    dup
    loads
    dup
    len
    dup
    intc_1 // 8
    -
    dig 2
    dig 1
    uncover 3
    substring3
    uncover 2
    intc_2 // 0
    uncover 3
    extract3
    swap
    btoi
    cover 2
    stores
    // tests/artifacts/Arrays/uint64.py:287
    // assert popped == expected
    frame_dig 1
    dup
    cover 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:288
    // expected -= 1
    intc_0 // 1
    -
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    frame_dig 2
    intc_0 // 1
    +
    frame_bury 2
    b test_array_for_header@2

test_array_after_for@4:
    // tests/artifacts/Arrays/uint64.py:28
    // assert arr.length == 3
    frame_dig 0
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:29
    // assert arr[-1] == 1
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:31
    // arr.append(UInt64(43))
    pushint 43 // 43
    itob
    concat // on error: max array length exceeded
    dup2
    stores
    // tests/artifacts/Arrays/uint64.py:32
    // assert arr.length == 4
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:33
    // assert arr[-1] == 43
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 43 // 43
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:34
    // assert arr[0] == 42
    intc_2 // 0
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:36
    // add_x(arr, UInt64(10))
    dup
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:37
    // assert arr.length == 14
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:38
    // assert arr[-1] == 9
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:40
    // arr.append(UInt64(44))
    pushint 44 // 44
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:41
    // assert arr.length == 15
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:42
    // assert arr[-1] == 44
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:272
    // arr.append(UInt64(99))
    pushint 99 // 99
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:273
    // arr2.append(UInt64(100))
    pushint 100 // 100
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:44
    // return_ref(arr, arr)[0] += 2
    dup
    intc_2 // 0
    extract_uint64
    pushint 2 // 2
    +
    itob
    replace2 0
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:45
    // assert arr.length == 17
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 17 // 17
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:46
    // assert arr[0] == 44
    dig 1
    intc_2 // 0
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:47
    // assert arr[-2] == 99
    dup
    pushint 2 // 2
    -
    intc_1 // 8
    *
    dig 2
    swap
    extract_uint64
    pushint 99 // 99
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:48
    // assert arr[-1] == 100
    intc_0 // 1
    -
    intc_1 // 8
    *
    extract_uint64
    pushint 100 // 100
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_extend() -> void:
test_array_extend:
    // tests/artifacts/Arrays/uint64.py:52
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:53
    // add_x(arr, UInt64(1))
    dup
    intc_0 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:57
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/uint64.py:59
    // arr.extend(arr2)
    dup
    loads
    // tests/artifacts/Arrays/uint64.py:57
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/uint64.py:59
    // arr.extend(arr2)
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:60
    // assert arr.length == 4
    len
    intc_1 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_multiple_append() -> void:
test_array_multiple_append:
    // tests/artifacts/Arrays/uint64.py:64
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:65
    // add_x(arr, UInt64(1))
    dup
    intc_0 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:66
    // arr.append(UInt64(1))
    dup
    loads
    intc_0 // 1
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:67
    // arr.append(UInt64(2))
    pushint 2 // 2
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:68
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:69
    // assert arr.length == 4
    len
    intc_1 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_too_long() -> void:
test_array_too_long:
    // tests/artifacts/Arrays/uint64.py:75-76
    // @arc4.abimethod()
    // def test_array_too_long(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:77
    // array = ReferenceArray[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(512):
    intc_2 // 0

test_array_too_long_for_header@1:
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(512):
    frame_dig 1
    intc 4 // 512
    <
    bz test_array_too_long_after_for@4
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:79
    // array.append(i)
    frame_dig 1
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(512):
    intc_0 // 1
    +
    frame_bury 1
    b test_array_too_long_for_header@1

test_array_too_long_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:80
    // assert array.length == 512, "array is expected length"
    dup
    len
    intc_1 // 8
    /
    intc 4 // 512
    ==
    assert // array is expected length
    // tests/artifacts/Arrays/uint64.py:82
    // array.append(UInt64(512))  # this will fail
    intc 4 // 512
    itob
    concat // on error: max array length exceeded
    pop
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_copy_and_extend() -> void:
test_array_copy_and_extend:
    // tests/artifacts/Arrays/uint64.py:84-85
    // @arc4.abimethod()
    // def test_array_copy_and_extend(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:86
    // array = ReferenceArray[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:87
    // for i in urange(5):
    intc_2 // 0

test_array_copy_and_extend_for_header@1:
    // tests/artifacts/Arrays/uint64.py:87
    // for i in urange(5):
    frame_dig 1
    intc_3 // 5
    <
    bz test_array_copy_and_extend_after_for@4
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:88
    // array.append(i)
    frame_dig 1
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:87
    // for i in urange(5):
    intc_0 // 1
    +
    frame_bury 1
    b test_array_copy_and_extend_for_header@1

test_array_copy_and_extend_after_for@4:
    frame_dig 0
    dup
    // tests/artifacts/Arrays/uint64.py:91
    // array.append(UInt64(5))
    intc_3 // 5
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:92
    // assert array.length == 6
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:93
    // assert array[-1] == 5, "expected 5"
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 5
    dig 1
    // tests/artifacts/Arrays/uint64.py:95
    // assert array2.length == 5
    dup
    len
    intc_1 // 8
    /
    dup
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:96
    // assert array2[-1] == 4, "expected 4"
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:98
    // array.extend(array2)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:99
    // assert array.length == 11
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 11 // 11
    ==
    assert
    uncover 2
    // tests/artifacts/Arrays/uint64.py:100
    // assert array2.length == 5
    len
    intc_1 // 8
    /
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:101
    // assert array[-1] == 4, "expected 4"
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:102
    // assert array[4] == 4, "expected 4"
    dup
    pushint 32 // 32
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:103
    // assert array[5] == 5, "expected 4"
    dup
    pushint 40 // 40
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:104
    // assert array[6] == 0, "expected 4"
    pushint 48 // 48
    extract_uint64
    !
    assert // expected 4
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_evaluation_order() -> void:
test_array_evaluation_order:
    // tests/artifacts/Arrays/uint64.py:108
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    // tests/artifacts/Arrays/uint64.py:109
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:110
    // append_length_and_return(arr).extend(append_length_and_return(arr))
    dup
    callsub append_length_and_return
    dig 1
    callsub append_length_and_return
    loads
    dig 1
    loads
    swap
    concat // on error: max array length exceeded
    stores
    // tests/artifacts/Arrays/uint64.py:111
    // assert arr.length == 6
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:112
    // assert arr[0] == 3
    dup
    intc_2 // 0
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:113
    // assert arr[1] == 1
    dup
    intc_1 // 8
    extract_uint64
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:114
    // assert arr[2] == 2
    dup
    pushint 16 // 16
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:115
    // assert arr[3] == 3
    dup
    pushint 24 // 24
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:116
    // assert arr[4] == 1
    dup
    pushint 32 // 32
    extract_uint64
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:117
    // assert arr[5] == 2
    pushint 40 // 40
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:119
    // arr[append_length_and_return(arr)[0]] = append_length_and_return(arr)[-1]
    dup
    callsub append_length_and_return
    loads
    dup
    len
    intc_1 // 8
    /
    intc_0 // 1
    -
    intc_1 // 8
    *
    intc_1 // 8
    extract3 // on error: index access is out of bounds
    dig 1
    callsub append_length_and_return
    loads
    intc_2 // 0
    extract_uint64
    dig 2
    loads
    swap
    intc_1 // 8
    *
    uncover 2
    replace3
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:120
    // assert arr.length == 8
    dup
    len
    intc_1 // 8
    /
    intc_1 // 8
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:121
    // assert arr[6] == 6
    dup
    pushint 48 // 48
    extract_uint64
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:122
    // assert arr[7] == 7
    dup
    pushint 56 // 56
    extract_uint64
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:123
    // assert arr[3] == 6
    pushint 24 // 24
    extract_uint64
    pushint 6 // 6
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_assignment_maximum_cursage() -> void:
test_array_assignment_maximum_cursage:
    // tests/artifacts/Arrays/uint64.py:127
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    // tests/artifacts/Arrays/uint64.py:128
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:129
    // append_length_and_return(arr)[0] = UInt64(42)
    dup
    callsub append_length_and_return
    pushint 42 // 42
    itob
    dig 1
    loads
    swap
    replace2 0
    stores
    // tests/artifacts/Arrays/uint64.py:130
    // assert arr.length == 2
    loads
    dup
    len
    intc_1 // 8
    /
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:131
    // assert arr[0] == 42
    dup
    intc_2 // 0
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:132
    // assert arr[1] == 1
    intc_1 // 8
    extract_uint64
    intc_0 // 1
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_allocations(num: uint64) -> void:
test_allocations:
    // tests/artifacts/Arrays/uint64.py:134-135
    // @arc4.abimethod()
    // def test_allocations(self, num: UInt64) -> None:
    proto 1 0
    // tests/artifacts/Arrays/uint64.py:136
    // for _i in urange(num):
    intc_2 // 0

test_allocations_for_header@1:
    // tests/artifacts/Arrays/uint64.py:136
    // for _i in urange(num):
    frame_dig 0
    frame_dig -1
    <
    bz test_allocations_after_for@4
    // tests/artifacts/Arrays/uint64.py:137
    // alloc_test = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:138
    // add_x(alloc_test, UInt64(1))
    intc_0 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:136
    // for _i in urange(num):
    frame_dig 0
    intc_0 // 1
    +
    frame_bury 0
    b test_allocations_for_header@1

test_allocations_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_iteration() -> void:
test_iteration:
    // tests/artifacts/Arrays/uint64.py:140-141
    // @arc4.abimethod()
    // def test_iteration(self) -> None:
    proto 0 0
    intc_2 // 0
    dup
    bytec_0 // ""
    // tests/artifacts/Arrays/uint64.py:142
    // arr = ReferenceArray[UInt64]()
    dupn 7
    // tests/artifacts/Arrays/uint64.py:143
    // for val in urange(5):
    intc_2 // 0

test_iteration_for_header@1:
    // tests/artifacts/Arrays/uint64.py:143
    // for val in urange(5):
    frame_dig 10
    intc_3 // 5
    <
    bz test_iteration_after_for@4
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:144
    // arr.append(val)
    frame_dig 10
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_bury 9
    // tests/artifacts/Arrays/uint64.py:143
    // for val in urange(5):
    intc_0 // 1
    +
    frame_bury 10
    b test_iteration_for_header@1

test_iteration_after_for@4:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:145
    // assert arr.length == 5, "expected array of length 5"
    len
    intc_1 // 8
    /
    dup
    frame_bury 2
    intc_3 // 5
    ==
    assert // expected array of length 5
    // tests/artifacts/Arrays/uint64.py:147-148
    // # iterate
    // last = UInt64(0)
    intc_2 // 0
    frame_bury 7
    intc_2 // 0
    frame_bury 6

test_iteration_for_header@5:
    // tests/artifacts/Arrays/uint64.py:149
    // for value in arr:
    frame_dig 6
    frame_dig 2
    <
    bz test_iteration_after_for@8
    frame_dig 9
    frame_dig 6
    dup
    cover 2
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:150
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 7
    >=
    assert // array is not sorted
    swap
    intc_0 // 1
    +
    frame_bury 6
    frame_bury 7
    b test_iteration_for_header@5

test_iteration_after_for@8:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:153-154
    // # enumerate
    // for idx, value in uenumerate(arr):
    len
    intc_1 // 8
    /
    frame_bury 3
    intc_2 // 0
    frame_bury 5

test_iteration_for_header@9:
    // tests/artifacts/Arrays/uint64.py:153-154
    // # enumerate
    // for idx, value in uenumerate(arr):
    frame_dig 5
    frame_dig 3
    <
    bz test_iteration_after_for@12
    frame_dig 9
    frame_dig 5
    dup
    cover 2
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:155
    // assert value == idx, "incorrect array value"
    dig 1
    ==
    assert // incorrect array value
    intc_0 // 1
    +
    frame_bury 5
    b test_iteration_for_header@9

test_iteration_after_for@12:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:157-158
    // # reverse
    // for value in reversed(arr):
    len
    intc_1 // 8
    /
    frame_bury 8

test_iteration_for_header@13:
    // tests/artifacts/Arrays/uint64.py:157-158
    // # reverse
    // for value in reversed(arr):
    frame_dig 8
    bz test_iteration_after_for@16
    frame_dig 8
    intc_0 // 1
    -
    dup
    frame_bury 8
    frame_dig 9
    swap
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:159
    // assert value <= last, "array is not sorted"
    dup
    frame_dig 7
    <=
    assert // array is not sorted
    frame_bury 7
    b test_iteration_for_header@13

test_iteration_after_for@16:
    // tests/artifacts/Arrays/uint64.py:162
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    pushbytes 0x0000
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:142
    // arr = ReferenceArray[UInt64]()
    bytec_0 // 0x
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:164
    // for i in urange(5):
    intc_2 // 0
    frame_bury 4

test_iteration_for_header@17:
    // tests/artifacts/Arrays/uint64.py:164
    // for i in urange(5):
    frame_dig 4
    intc_3 // 5
    <
    bz test_iteration_after_for@20
    // tests/artifacts/Arrays/uint64.py:165
    // arc4_arr.append(arc4.UInt64(i))
    frame_dig 4
    dup
    itob
    frame_dig 0
    dup
    cover 2
    dig 1
    concat // on error: max array length exceeded
    uncover 2
    intc_2 // 0
    extract_uint16
    intc_0 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    frame_dig 1
    // tests/artifacts/Arrays/uint64.py:166
    // native_arr.append(arc4.UInt64(i))
    swap
    concat // on error: max array length exceeded
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:164
    // for i in urange(5):
    intc_0 // 1
    +
    frame_bury 4
    b test_iteration_for_header@17

test_iteration_after_for@20:
    // tests/artifacts/Arrays/uint64.py:167
    // combined_arr = arc4_arr + native_arr
    frame_dig 0
    frame_dig 1
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_1 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/uint64.py:168
    // assert combined_arr.length == 10
    dup
    intc_2 // 0
    extract_uint16
    pushint 10 // 10
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:169
    // assert combined_arr[0] == 0
    dup
    extract 2 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:170
    // assert combined_arr[4] == 4
    dup
    extract 34 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:171
    // assert combined_arr[5] == 0
    dup
    extract 42 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:172
    // assert combined_arr[9] == 4
    extract 74 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_quicksort() -> void:
test_quicksort:
    // tests/artifacts/Arrays/uint64.py:174-175
    // @arc4.abimethod()
    // def test_quicksort(self) -> None:
    proto 0 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:176-177
    // # create pseudo random array from sender address
    // rnd = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:178
    // for b in Txn.sender.bytes:
    txn Sender
    intc_2 // 0

test_quicksort_for_header@1:
    // tests/artifacts/Arrays/uint64.py:178
    // for b in Txn.sender.bytes:
    frame_dig 5
    pushint 32 // 32
    <
    bz test_quicksort_after_for@4
    // tests/artifacts/Arrays/uint64.py:179
    // rnd.append(op.btoi(b))
    frame_dig 4
    frame_dig 5
    dup
    cover 2
    getbyte
    frame_dig 3
    dup
    cover 2
    loads
    swap
    itob
    concat // on error: max array length exceeded
    stores
    intc_0 // 1
    +
    frame_bury 5
    b test_quicksort_for_header@1

test_quicksort_after_for@4:
    // tests/artifacts/Arrays/uint64.py:180
    // assert rnd.length == 32, "expected array of length 32"
    frame_dig 3
    dup
    loads
    len
    intc_1 // 8
    /
    dup
    pushint 32 // 32
    ==
    assert // expected array of length 32
    // tests/artifacts/Arrays/uint64.py:182-183
    // # sort the array
    // quicksort_window(rnd, UInt64(0), rnd.length - 1)
    intc_0 // 1
    -
    dig 1
    intc_2 // 0
    uncover 2
    callsub quicksort_window
    // tests/artifacts/Arrays/uint64.py:185-186
    // # array should now be in ascending order
    // last = UInt64(0)
    intc_2 // 0
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:187
    // for value in rnd:
    loads
    len
    intc_1 // 8
    /
    frame_bury 0
    intc_2 // 0
    frame_bury 1

test_quicksort_for_header@5:
    // tests/artifacts/Arrays/uint64.py:187
    // for value in rnd:
    frame_dig 1
    frame_dig 0
    <
    bz test_quicksort_after_for@8
    frame_dig 3
    loads
    frame_dig 1
    dup
    cover 2
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:188
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 2
    >=
    assert // array is not sorted
    swap
    intc_0 // 1
    +
    frame_bury 1
    frame_bury 2
    b test_quicksort_for_header@5

test_quicksort_after_for@8:
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_unobserved_write() -> void:
test_unobserved_write:
    // tests/artifacts/Arrays/uint64.py:193
    // arr = create_array()
    callsub create_array
    // tests/artifacts/Arrays/uint64.py:194
    // last = arr.length - 1
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    intc_0 // 1
    -
    // tests/artifacts/Arrays/uint64.py:195
    // arr[last] = UInt64(0)  # write
    intc_2 // 0
    itob
    swap
    intc_1 // 8
    *
    uncover 2
    dig 1
    uncover 3
    replace3
    dig 2
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:196
    // assert_last_is_zero(arr)
    dig 1
    callsub assert_last_is_zero
    // tests/artifacts/Arrays/uint64.py:197
    // arr[last] = UInt64(1)  # write
    intc_0 // 1
    itob
    dig 2
    loads
    dig 2
    uncover 2
    replace3
    uncover 2
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:198
    // assert arr[last] == 1
    swap
    extract_uint64
    intc_0 // 1
    ==
    assert
    retsub


// _puya_lib.mem.new_slot() -> uint64:
_puya_lib.mem.new_slot:
    load 0
    bitlen
    load 0
    pushint 256 // 256
    dig 2
    -
    intc_2 // 0
    setbit // on error: no available slots
    store 0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
@@ -134,6 +144,14 @@
                     "type": "void"
                 }
             },
+            {
+                "name": "test_array_assignment_maximum_cursage",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
             {
                 "name": "test_allocations",
                 "args": [
@@ -162,6 +180,14 @@
                 "returns": {
                     "type": "void"
                 }
+            },
+            {
+                "name": "test_unobserved_write",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
             }
         ],
         "networks": {}
diff --git a/tests/artifacts/Arrays/data/Contract.arc56.json b/tests/artifacts/Arrays/data/Contract.arc56.json
index 0f7d2cbe..1a2ddf34 100644
--- a/tests/artifacts/Arrays/data/Contract.arc56.json
+++ b/tests/artifacts/Arrays/data/Contract.arc56.json
@@ -114,6 +114,22 @@
             "events": [],
             "recommendations": {}
         },
+        {
+            "name": "test_array_assignment_maximum_cursage",
+            "args": [],
+            "returns": {
+                "type": "void"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
+        },
         {
             "name": "test_allocations",
             "args": [
@@ -166,6 +182,22 @@
             "readonly": false,
             "events": [],
             "recommendations": {}
+        },
+        {
+            "name": "test_unobserved_write",
+            "args": [],
+            "returns": {
+                "type": "void"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
         }
     ],
     "arcs": [
@@ -206,115 +238,130 @@
             "sourceInfo": [
                 {
                     "pc": [
-                        178,
-                        190,
-                        202,
-                        218,
-                        230,
-                        242,
-                        254,
-                        263,
-                        275,
-                        287
+                        192,
+                        204,
+                        216,
+                        228,
+                        244,
+                        256,
+                        268,
+                        280,
+                        292,
+                        301,
+                        313,
+                        325
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        1006
+                        1044
                     ],
                     "errorMessage": "array is expected length"
                 },
                 {
                     "pc": [
-                        1435,
-                        1520,
-                        1746
+                        1477,
+                        1556,
+                        1778
                     ],
                     "errorMessage": "array is not sorted"
                 },
                 {
                     "pc": [
-                        304
+                        342
                     ],
                     "errorMessage": "can only call when creating"
                 },
                 {
                     "pc": [
-                        181,
-                        193,
-                        205,
-                        221,
-                        233,
-                        245,
-                        257,
-                        266,
-                        278,
-                        290
+                        195,
+                        207,
+                        219,
+                        231,
+                        247,
+                        259,
+                        271,
+                        283,
+                        295,
+                        304,
+                        316,
+                        328
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        1095,
                         1128,
-                        1138,
-                        1147,
-                        1154
+                        1158,
+                        1166,
+                        1173,
+                        1178
                     ],
                     "errorMessage": "expected 4"
                 },
                 {
                     "pc": [
-                        1070
+                        1106
                     ],
                     "errorMessage": "expected 5"
                 },
                 {
                     "pc": [
-                        1697
+                        1732
                     ],
                     "errorMessage": "expected array of length 32"
                 },
                 {
                     "pc": [
-                        1403
+                        1448
                     ],
                     "errorMessage": "expected array of length 5"
                 },
                 {
                     "pc": [
-                        1480
+                        1519
                     ],
                     "errorMessage": "incorrect array value"
                 },
                 {
                     "pc": [
-                        566,
-                        590,
-                        730,
-                        801,
-                        829,
-                        833,
-                        916,
-                        946,
-                        950,
-                        954,
+                        480,
+                        489,
+                        1273
+                    ],
+                    "errorMessage": "index access is out of bounds"
+                },
+                {
+                    "pc": [
+                        589,
+                        638,
+                        662,
+                        793,
+                        855,
+                        880,
+                        884,
+                        955,
+                        983,
                         987,
-                        1010,
-                        1032,
-                        1047,
-                        1096,
-                        1180,
-                        1383,
-                        1575,
-                        1677
+                        991,
+                        1025,
+                        1048,
+                        1071,
+                        1086,
+                        1129,
+                        1204,
+                        1428,
+                        1592,
+                        1610,
+                        1624,
+                        1712
                     ],
                     "errorMessage": "max array length exceeded"
                 },
                 {
                     "pc": [
-                        1770
+                        1855
                     ],
                     "errorMessage": "no available slots"
                 }
@@ -327,19 +374,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 8 0 1 5 512
    bytecblock 0x 0x000000000000000100000000000000020000000000000003 0x0000000000000000 0x0000000000000004
    pushbytes 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    store 0
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@15
    pushbytess 0xa33be873 0xe0c378e9 0x366f509d 0x58351a50 0xfa99e984 0xa20e440f 0x179ac3f9 0xf17f6f0a 0x845e1b4e 0x7621cfd1 // method "test_array()void", method "test_array_extend()void", method "test_array_multiple_append()void", method "overhead()void", method "test_array_too_long()void", method "test_array_copy_and_extend()void", method "test_array_evaluation_order()void", method "test_allocations(uint64)void", method "test_iteration()void", method "test_quicksort()void"
    txna ApplicationArgs 0
    match main_test_array_route@3 main_test_array_extend_route@4 main_test_array_multiple_append_route@5 main_overhead_route@6 main_test_array_too_long_route@7 main_test_array_copy_and_extend_route@8 main_test_array_evaluation_order_route@9 main_test_allocations_route@10 main_test_iteration_route@11 main_test_quicksort_route@12

main_after_if_else@19:
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    intc_1 // 0
    return

main_test_quicksort_route@12:
    // tests/artifacts/Arrays/uint64.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_quicksort
    intc_2 // 1
    return

main_test_iteration_route@11:
    // tests/artifacts/Arrays/uint64.py:122
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_iteration
    intc_2 // 1
    return

main_test_allocations_route@10:
    // tests/artifacts/Arrays/uint64.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/uint64.py:116
    // @arc4.abimethod()
    callsub test_allocations
    intc_2 // 1
    return

main_test_array_evaluation_order_route@9:
    // tests/artifacts/Arrays/uint64.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_evaluation_order
    intc_2 // 1
    return

main_test_array_copy_and_extend_route@8:
    // tests/artifacts/Arrays/uint64.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_copy_and_extend
    intc_2 // 1
    return

main_test_array_too_long_route@7:
    // tests/artifacts/Arrays/uint64.py:66
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_too_long
    intc_2 // 1
    return

main_overhead_route@6:
    // tests/artifacts/Arrays/uint64.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    intc_2 // 1
    return

main_test_array_multiple_append_route@5:
    // tests/artifacts/Arrays/uint64.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_multiple_append
    intc_2 // 1
    return

main_test_array_extend_route@4:
    // tests/artifacts/Arrays/uint64.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_extend
    intc_2 // 1
    return

main_test_array_route@3:
    // tests/artifacts/Arrays/uint64.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array
    intc_2 // 1
    return

main_bare_routing@15:
    // tests/artifacts/Arrays/uint64.py:4
    // class Contract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@19
    txn ApplicationID
    !
    assert // can only call when creating
    intc_2 // 1
    return


// tests.artifacts.Arrays.uint64.quicksort_window(arr: uint64, window_left: uint64, window_right: uint64) -> void:
quicksort_window:
    // tests/artifacts/Arrays/uint64.py:174-175
    // @subroutine
    // def quicksort_window(arr: Array[UInt64], window_left: UInt64, window_right: UInt64) -> None:
    proto 3 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:178
    // pivot = arr[(window_left + window_right) // 2]
    frame_dig -2
    frame_dig -1
    +
    pushint 2 // 2
    /
    frame_dig -3
    loads
    swap
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    frame_dig -1
    frame_dig -2

quicksort_window_while_top@3:
    // tests/artifacts/Arrays/uint64.py:182-183
    // # move left of window towards pivot
    // while arr[left] < pivot:
    frame_dig -3
    loads
    frame_dig 5
    intc_0 // 8
    *
    dup
    frame_bury 0
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    frame_dig 3
    <
    bz quicksort_window_while_top@6
    // tests/artifacts/Arrays/uint64.py:184
    // left += 1
    frame_dig 5
    intc_2 // 1
    +
    frame_bury 5
    b quicksort_window_while_top@3

quicksort_window_while_top@6:
    // tests/artifacts/Arrays/uint64.py:185-186
    // # move right of window towards pivot
    // while pivot < arr[right]:
    frame_dig -3
    loads
    frame_dig 4
    intc_0 // 8
    *
    dup
    frame_bury 1
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    frame_dig 3
    >
    bz quicksort_window_after_while@10
    // tests/artifacts/Arrays/uint64.py:187-188
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:190
    // right -= 1
    frame_dig 4
    intc_2 // 1
    -
    frame_bury 4
    b quicksort_window_while_top@6

quicksort_window_after_while@22:
    // tests/artifacts/Arrays/uint64.py:218-219
    // # sort left half of window
    // if window_left < right:
    frame_dig -2
    frame_dig 4
    <
    bz quicksort_window_after_if_else@24
    // tests/artifacts/Arrays/uint64.py:220
    // quicksort_window(arr, window_left, right)
    frame_dig -3
    frame_dig -2
    frame_dig 4
    callsub quicksort_window

quicksort_window_after_if_else@24:
    // tests/artifacts/Arrays/uint64.py:221-222
    // # sort right half of window
    // if left < window_right:
    frame_dig 5
    frame_dig -1
    <
    bz quicksort_window_after_if_else@26
    // tests/artifacts/Arrays/uint64.py:223
    // quicksort_window(arr, left, window_right)
    frame_dig -3
    frame_dig 5
    frame_dig -1
    callsub quicksort_window

quicksort_window_after_if_else@26:
    retsub

quicksort_window_after_while@10:
    // tests/artifacts/Arrays/uint64.py:192-193
    // # if window isn't empty then swap values and move window in
    // if left < right:
    frame_dig 5
    frame_dig 4
    <
    bz quicksort_window_after_if_else@16
    // tests/artifacts/Arrays/uint64.py:194
    // arr[left], arr[right] = arr[right], arr[left]
    frame_dig -3
    loads
    dup
    frame_dig 1
    dup
    cover 3
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    dig 1
    frame_dig 0
    dup
    cover 4
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    swap
    itob
    uncover 2
    uncover 3
    uncover 2
    replace3
    swap
    itob
    swap
    cover 2
    replace3
    frame_dig -3
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:195
    // left += 1
    frame_dig 5
    intc_2 // 1
    +
    frame_bury 5
    // tests/artifacts/Arrays/uint64.py:196-197
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:199
    // right -= 1
    frame_dig 4
    intc_2 // 1
    -
    dup
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:200-201
    // # explicit continue to avoid hitting outer break
    // if left <= right:
    frame_dig 5
    >=
    bnz quicksort_window_while_top@3
    b quicksort_window_after_while@22

quicksort_window_after_if_else@16:
    // tests/artifacts/Arrays/uint64.py:206-207
    // # if window is just one item, don't bother swapping, but still adjust window
    // if left == right:
    frame_dig 5
    frame_dig 4
    ==
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:208
    // left += 1
    frame_dig 5
    intc_2 // 1
    +
    frame_bury 5
    frame_dig 4
    dup
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:209-210
    // # don't decrement right if it would go negative
    // if right:
    bz quicksort_window_after_if_else@19
    // tests/artifacts/Arrays/uint64.py:211
    // right -= 1
    frame_dig 4
    intc_2 // 1
    -
    frame_bury 2

quicksort_window_after_if_else@19:
    frame_dig 2
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:212-214
    // # loop always ends in this scenario
    // # and an explict break consumes fewer ops
    // break
    b quicksort_window_after_while@22


// tests.artifacts.Arrays.uint64.add_x(arr: uint64, x: uint64) -> void:
add_x:
    // tests/artifacts/Arrays/uint64.py:233-234
    // @subroutine
    // def add_x(arr: Array[UInt64], x: UInt64) -> None:
    proto 2 0
    // tests/artifacts/Arrays/uint64.py:235
    // for i in urange(x):
    intc_1 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/uint64.py:235
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/uint64.py:236
    // arr.append(i)
    frame_dig 0
    dup
    itob
    frame_dig -2
    loads
    swap
    concat // on error: max array length exceeded
    frame_dig -2
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:235
    // for i in urange(x):
    intc_2 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.append_length_and_return(arr: uint64) -> uint64:
append_length_and_return:
    // tests/artifacts/Arrays/uint64.py:247-248
    // @subroutine
    // def append_length_and_return(arr: Array[UInt64]) -> Array[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/uint64.py:249
    // arr.append(arr.length)
    frame_dig -1
    loads
    dup
    len
    intc_0 // 8
    /
    itob
    concat // on error: max array length exceeded
    frame_dig -1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:250
    // return arr
    frame_dig -1
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array() -> void:
test_array:
    // tests/artifacts/Arrays/uint64.py:5-6
    // @arc4.abimethod()
    // def test_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:7
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    // tests/artifacts/Arrays/uint64.py:10
    // arr.append(UInt64(42))
    pushint 42 // 42
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:14
    // add_x(arr, UInt64(5))
    dup
    intc_3 // 5
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:15
    // assert arr.length == 6
    loads
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:16
    // assert arr[-1] == 4
    intc_2 // 1
    -
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:18
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 4 // 4
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    intc_1 // 0

test_array_for_header@2:
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    frame_dig 2
    // tests/artifacts/Arrays/uint64.py:18
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 3 // 3
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    <
    bz test_array_after_for@4
    // tests/artifacts/Arrays/uint64.py:242
    // popped = arr.pop()
    frame_dig 0
    dup
    loads
    dup
    len
    intc_0 // 8
    -
    dup
    intc_0 // 8
    /
    dig 2
    intc_1 // 0
    uncover 3
    extract3
    swap
    intc_0 // 8
    *
    uncover 2
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    cover 2
    stores
    // tests/artifacts/Arrays/uint64.py:243
    // assert popped == expected
    frame_dig 1
    dup
    cover 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:244
    // expected -= 1
    intc_2 // 1
    -
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:241
    // for _i in urange(x):
    frame_dig 2
    intc_2 // 1
    +
    frame_bury 2
    b test_array_for_header@2

test_array_after_for@4:
    // tests/artifacts/Arrays/uint64.py:19
    // assert arr.length == 3
    frame_dig 0
    dup
    loads
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:20
    // assert arr[-1] == 1
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:22
    // arr.append(UInt64(43))
    pushint 43 // 43
    itob
    concat // on error: max array length exceeded
    dup2
    stores
    // tests/artifacts/Arrays/uint64.py:23
    // assert arr.length == 4
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:24
    // assert arr[-1] == 43
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 43 // 43
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:25
    // assert arr[0] == 42
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:27
    // add_x(arr, UInt64(10))
    dup
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:28
    // assert arr.length == 14
    dup
    loads
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:29
    // assert arr[-1] == 9
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:31
    // arr.append(UInt64(44))
    pushint 44 // 44
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:32
    // assert arr.length == 15
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:33
    // assert arr[-1] == 44
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:228
    // arr.append(UInt64(99))
    pushint 99 // 99
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:229
    // arr2.append(UInt64(100))
    pushint 100 // 100
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:35
    // return_ref(arr, arr)[0] += 2
    dup
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 2 // 2
    +
    itob
    replace2 0
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:36
    // assert arr.length == 17
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 17 // 17
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:37
    // assert arr[0] == 44
    dig 1
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:38
    // assert arr[-2] == 99
    dup
    pushint 2 // 2
    -
    intc_0 // 8
    *
    dig 2
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 99 // 99
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:39
    // assert arr[-1] == 100
    intc_2 // 1
    -
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 100 // 100
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_extend() -> void:
test_array_extend:
    // tests/artifacts/Arrays/uint64.py:43
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:44
    // add_x(arr, UInt64(1))
    dup
    intc_2 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:48
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/uint64.py:50
    // arr.extend(arr2)
    dup
    loads
    // tests/artifacts/Arrays/uint64.py:48
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/uint64.py:50
    // arr.extend(arr2)
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:51
    // assert arr.length == 4
    len
    intc_0 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_multiple_append() -> void:
test_array_multiple_append:
    // tests/artifacts/Arrays/uint64.py:55
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:56
    // add_x(arr, UInt64(1))
    dup
    intc_2 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:57
    // arr.append(UInt64(1))
    intc_2 // 1
    itob
    dig 1
    loads
    swap
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:58
    // arr.append(UInt64(2))
    pushint 2 // 2
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:59
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:60
    // assert arr.length == 4
    len
    intc_0 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_too_long() -> void:
test_array_too_long:
    // tests/artifacts/Arrays/uint64.py:66-67
    // @arc4.abimethod()
    // def test_array_too_long(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:68
    // array = Array[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:69
    // for i in urange(512):
    intc_1 // 0

test_array_too_long_for_header@1:
    // tests/artifacts/Arrays/uint64.py:69
    // for i in urange(512):
    frame_dig 1
    intc 4 // 512
    <
    bz test_array_too_long_after_for@4
    // tests/artifacts/Arrays/uint64.py:70
    // array.append(i)
    frame_dig 1
    dup
    itob
    frame_dig 0
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:69
    // for i in urange(512):
    intc_2 // 1
    +
    frame_bury 1
    b test_array_too_long_for_header@1

test_array_too_long_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:71
    // assert array.length == 512, "array is expected length"
    dup
    len
    intc_0 // 8
    /
    intc 4 // 512
    ==
    assert // array is expected length
    // tests/artifacts/Arrays/uint64.py:73
    // array.append(UInt64(512))  # this will fail
    intc 4 // 512
    itob
    concat // on error: max array length exceeded
    pop
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_copy_and_extend() -> void:
test_array_copy_and_extend:
    // tests/artifacts/Arrays/uint64.py:75-76
    // @arc4.abimethod()
    // def test_array_copy_and_extend(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:77
    // array = Array[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(5):
    intc_1 // 0

test_array_copy_and_extend_for_header@1:
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(5):
    frame_dig 1
    intc_3 // 5
    <
    bz test_array_copy_and_extend_after_for@4
    // tests/artifacts/Arrays/uint64.py:79
    // array.append(i)
    frame_dig 1
    dup
    itob
    frame_dig 0
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(5):
    intc_2 // 1
    +
    frame_bury 1
    b test_array_copy_and_extend_for_header@1

test_array_copy_and_extend_after_for@4:
    frame_dig 0
    dup
    // tests/artifacts/Arrays/uint64.py:82
    // array.append(UInt64(5))
    intc_3 // 5
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:83
    // assert array.length == 6
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:84
    // assert array[-1] == 5, "expected 5"
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 5
    dig 1
    // tests/artifacts/Arrays/uint64.py:86
    // assert array2.length == 5
    dup
    len
    intc_0 // 8
    /
    dup
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:87
    // assert array2[-1] == 4, "expected 4"
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:89
    // array.extend(array2)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:90
    // assert array.length == 11
    dup
    len
    intc_0 // 8
    /
    dup
    pushint 11 // 11
    ==
    assert
    uncover 2
    // tests/artifacts/Arrays/uint64.py:91
    // assert array2.length == 5
    len
    intc_0 // 8
    /
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:92
    // assert array[-1] == 4, "expected 4"
    intc_2 // 1
    -
    intc_0 // 8
    *
    dig 1
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:93
    // assert array[4] == 4, "expected 4"
    dup
    extract 32 8
    intc_1 // 0
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:94
    // assert array[5] == 5, "expected 4"
    dup
    extract 40 8
    intc_1 // 0
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:95
    // assert array[6] == 0, "expected 4"
    extract 48 8
    intc_1 // 0
    extract_uint64
    !
    assert // expected 4
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_evaluation_order() -> void:
test_array_evaluation_order:
    // tests/artifacts/Arrays/uint64.py:99
    // arr = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    // tests/artifacts/Arrays/uint64.py:100
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:101
    // append_length_and_return(arr).extend(append_length_and_return(arr))
    dup
    callsub append_length_and_return
    dig 1
    callsub append_length_and_return
    loads
    dig 1
    loads
    swap
    concat // on error: max array length exceeded
    stores
    // tests/artifacts/Arrays/uint64.py:102
    // assert arr.length == 6
    dup
    loads
    dup
    len
    intc_0 // 8
    /
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:103
    // assert arr[0] == 3
    dup
    extract 0 8
    intc_1 // 0
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:104
    // assert arr[1] == 1
    dup
    extract 8 8
    intc_1 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:105
    // assert arr[2] == 2
    dup
    extract 16 8
    intc_1 // 0
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:106
    // assert arr[3] == 3
    dup
    extract 24 8
    intc_1 // 0
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:107
    // assert arr[4] == 1
    dup
    extract 32 8
    intc_1 // 0
    extract_uint64
    intc_2 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:108
    // assert arr[5] == 2
    extract 40 8
    intc_1 // 0
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:110
    // arr[append_length_and_return(arr)[0]] = append_length_and_return(arr)[-1]
    dup
    callsub append_length_and_return
    loads
    dup
    len
    intc_0 // 8
    /
    intc_2 // 1
    -
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    dig 1
    callsub append_length_and_return
    loads
    extract 0 8
    intc_1 // 0
    extract_uint64
    dig 2
    loads
    swap
    intc_0 // 8
    *
    uncover 2
    itob
    replace3
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:111
    // assert arr.length == 8
    dup
    len
    intc_0 // 8
    /
    intc_0 // 8
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:112
    // assert arr[6] == 6
    dup
    extract 48 8
    intc_1 // 0
    extract_uint64
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:113
    // assert arr[7] == 7
    dup
    extract 56 8
    intc_1 // 0
    extract_uint64
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:114
    // assert arr[3] == 6
    extract 24 8
    intc_1 // 0
    extract_uint64
    pushint 6 // 6
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_allocations(num: uint64) -> void:
test_allocations:
    // tests/artifacts/Arrays/uint64.py:116-117
    // @arc4.abimethod()
    // def test_allocations(self, num: UInt64) -> None:
    proto 1 0
    // tests/artifacts/Arrays/uint64.py:118
    // for _i in urange(num):
    intc_1 // 0

test_allocations_for_header@1:
    // tests/artifacts/Arrays/uint64.py:118
    // for _i in urange(num):
    frame_dig 0
    frame_dig -1
    <
    bz test_allocations_after_for@4
    // tests/artifacts/Arrays/uint64.py:119
    // alloc_test = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:120
    // add_x(alloc_test, UInt64(1))
    intc_2 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:118
    // for _i in urange(num):
    frame_dig 0
    intc_2 // 1
    +
    frame_bury 0
    b test_allocations_for_header@1

test_allocations_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_iteration() -> void:
test_iteration:
    // tests/artifacts/Arrays/uint64.py:122-123
    // @arc4.abimethod()
    // def test_iteration(self) -> None:
    proto 0 0
    intc_1 // 0
    dup
    bytec_0 // ""
    // tests/artifacts/Arrays/uint64.py:124
    // arr = Array[UInt64]()
    dupn 7
    // tests/artifacts/Arrays/uint64.py:125
    // for val in urange(5):
    intc_1 // 0

test_iteration_for_header@1:
    // tests/artifacts/Arrays/uint64.py:125
    // for val in urange(5):
    frame_dig 10
    intc_3 // 5
    <
    bz test_iteration_after_for@4
    // tests/artifacts/Arrays/uint64.py:126
    // arr.append(val)
    frame_dig 10
    dup
    itob
    frame_dig 9
    swap
    concat // on error: max array length exceeded
    frame_bury 9
    // tests/artifacts/Arrays/uint64.py:125
    // for val in urange(5):
    intc_2 // 1
    +
    frame_bury 10
    b test_iteration_for_header@1

test_iteration_after_for@4:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:127
    // assert arr.length == 5, "expected array of length 5"
    len
    intc_0 // 8
    /
    dup
    frame_bury 2
    intc_3 // 5
    ==
    assert // expected array of length 5
    // tests/artifacts/Arrays/uint64.py:129-130
    // # iterate
    // last = UInt64(0)
    intc_1 // 0
    frame_bury 7
    intc_1 // 0
    frame_bury 6

test_iteration_for_header@5:
    // tests/artifacts/Arrays/uint64.py:131
    // for value in arr:
    frame_dig 6
    frame_dig 2
    <
    bz test_iteration_after_for@8
    frame_dig 9
    frame_dig 6
    dup
    cover 2
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:132
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 7
    >=
    assert // array is not sorted
    swap
    intc_2 // 1
    +
    frame_bury 6
    frame_bury 7
    b test_iteration_for_header@5

test_iteration_after_for@8:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:135-136
    // # enumerate
    // for idx, value in uenumerate(arr):
    len
    intc_0 // 8
    /
    frame_bury 3
    intc_1 // 0
    frame_bury 5

test_iteration_for_header@9:
    // tests/artifacts/Arrays/uint64.py:135-136
    // # enumerate
    // for idx, value in uenumerate(arr):
    frame_dig 5
    frame_dig 3
    <
    bz test_iteration_after_for@12
    frame_dig 9
    frame_dig 5
    dup
    cover 2
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:137
    // assert value == idx, "incorrect array value"
    dig 1
    ==
    assert // incorrect array value
    intc_2 // 1
    +
    frame_bury 5
    b test_iteration_for_header@9

test_iteration_after_for@12:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:139-140
    // # reverse
    // for value in reversed(arr):
    len
    intc_0 // 8
    /
    frame_bury 8

test_iteration_for_header@13:
    // tests/artifacts/Arrays/uint64.py:139-140
    // # reverse
    // for value in reversed(arr):
    frame_dig 8
    bz test_iteration_after_for@16
    frame_dig 8
    intc_2 // 1
    -
    dup
    frame_bury 8
    frame_dig 9
    swap
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:141
    // assert value <= last, "array is not sorted"
    dup
    frame_dig 7
    <=
    assert // array is not sorted
    frame_bury 7
    b test_iteration_for_header@13

test_iteration_after_for@16:
    // tests/artifacts/Arrays/uint64.py:144
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    pushbytes 0x0000
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:145
    // native_arr = Array[arc4.UInt64]()
    bytec_0 // 0x
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:146
    // for i in urange(5):
    intc_1 // 0
    frame_bury 4

test_iteration_for_header@17:
    // tests/artifacts/Arrays/uint64.py:146
    // for i in urange(5):
    frame_dig 4
    intc_3 // 5
    <
    bz test_iteration_after_for@20
    // tests/artifacts/Arrays/uint64.py:147
    // arc4_arr.append(arc4.UInt64(i))
    frame_dig 0
    extract 2 0
    frame_dig 4
    dup
    cover 2
    itob
    swap
    dig 1
    concat
    dup
    len
    intc_0 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    frame_dig 1
    // tests/artifacts/Arrays/uint64.py:148
    // native_arr.append(arc4.UInt64(i))
    swap
    concat // on error: max array length exceeded
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:146
    // for i in urange(5):
    intc_2 // 1
    +
    frame_bury 4
    b test_iteration_for_header@17

test_iteration_after_for@20:
    // tests/artifacts/Arrays/uint64.py:149
    // combined_arr = arc4_arr + native_arr
    frame_dig 0
    extract 2 0
    frame_dig 1
    concat
    dup
    len
    intc_0 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/uint64.py:150
    // assert combined_arr.length == 10
    dup
    intc_1 // 0
    extract_uint16
    pushint 10 // 10
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:151
    // assert combined_arr[0] == 0
    dup
    extract 2 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:152
    // assert combined_arr[4] == 4
    dup
    extract 34 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:153
    // assert combined_arr[5] == 0
    dup
    extract 42 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:154
    // assert combined_arr[9] == 4
    extract 74 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_quicksort() -> void:
test_quicksort:
    // tests/artifacts/Arrays/uint64.py:156-157
    // @arc4.abimethod()
    // def test_quicksort(self) -> None:
    proto 0 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:158-159
    // # create pseudo random array from sender address
    // rnd = Array[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:160
    // for b in Txn.sender.bytes:
    txn Sender
    intc_1 // 0

test_quicksort_for_header@1:
    // tests/artifacts/Arrays/uint64.py:160
    // for b in Txn.sender.bytes:
    frame_dig 5
    pushint 32 // 32
    <
    bz test_quicksort_after_for@4
    // tests/artifacts/Arrays/uint64.py:161
    // rnd.append(op.btoi(b))
    frame_dig 4
    frame_dig 5
    dup
    cover 2
    getbyte
    itob
    frame_dig 3
    dup
    cover 2
    loads
    swap
    concat // on error: max array length exceeded
    stores
    intc_2 // 1
    +
    frame_bury 5
    b test_quicksort_for_header@1

test_quicksort_after_for@4:
    // tests/artifacts/Arrays/uint64.py:162
    // assert rnd.length == 32, "expected array of length 32"
    frame_dig 3
    dup
    loads
    len
    intc_0 // 8
    /
    dup
    pushint 32 // 32
    ==
    assert // expected array of length 32
    // tests/artifacts/Arrays/uint64.py:164-165
    // # sort the array
    // quicksort_window(rnd, UInt64(0), rnd.length - 1)
    intc_2 // 1
    -
    dig 1
    intc_1 // 0
    uncover 2
    callsub quicksort_window
    // tests/artifacts/Arrays/uint64.py:167-168
    // # array should now be in ascending order
    // last = UInt64(0)
    intc_1 // 0
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:169
    // for value in rnd:
    loads
    len
    intc_0 // 8
    /
    frame_bury 0
    intc_1 // 0
    frame_bury 1

test_quicksort_for_header@5:
    // tests/artifacts/Arrays/uint64.py:169
    // for value in rnd:
    frame_dig 1
    frame_dig 0
    <
    bz test_quicksort_after_for@8
    frame_dig 3
    loads
    frame_dig 1
    dup
    cover 2
    intc_0 // 8
    *
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:170
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 2
    >=
    assert // array is not sorted
    swap
    intc_2 // 1
    +
    frame_bury 1
    frame_bury 2
    b test_quicksort_for_header@5

test_quicksort_after_for@8:
    retsub


// _puya_lib.mem.new_slot() -> uint64:
_puya_lib.mem.new_slot:
    load 0
    bitlen
    load 0
    pushint 256 // 256
    dig 2
    -
    intc_1 // 0
    setbit // on error: no available slots
    store 0
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 8 0 5 512
    bytecblock 0x 0x000000000000000100000000000000020000000000000003 0x0000000000000000 0x0000000000000004
    pushbytes 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    store 0
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@17
    pushbytess 0xa33be873 0xe0c378e9 0x366f509d 0x58351a50 0xfa99e984 0xa20e440f 0x179ac3f9 0x45dcc836 0xf17f6f0a 0x845e1b4e 0x7621cfd1 0x5661a67c // method "test_array()void", method "test_array_extend()void", method "test_array_multiple_append()void", method "overhead()void", method "test_array_too_long()void", method "test_array_copy_and_extend()void", method "test_array_evaluation_order()void", method "test_array_assignment_maximum_cursage()void", method "test_allocations(uint64)void", method "test_iteration()void", method "test_quicksort()void", method "test_unobserved_write()void"
    txna ApplicationArgs 0
    match main_test_array_route@3 main_test_array_extend_route@4 main_test_array_multiple_append_route@5 main_overhead_route@6 main_test_array_too_long_route@7 main_test_array_copy_and_extend_route@8 main_test_array_evaluation_order_route@9 main_test_array_assignment_maximum_cursage_route@10 main_test_allocations_route@11 main_test_iteration_route@12 main_test_quicksort_route@13 main_test_unobserved_write_route@14

main_after_if_else@21:
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    intc_2 // 0
    return

main_test_unobserved_write_route@14:
    // tests/artifacts/Arrays/uint64.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_unobserved_write
    intc_0 // 1
    return

main_test_quicksort_route@13:
    // tests/artifacts/Arrays/uint64.py:174
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_quicksort
    intc_0 // 1
    return

main_test_iteration_route@12:
    // tests/artifacts/Arrays/uint64.py:140
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_iteration
    intc_0 // 1
    return

main_test_allocations_route@11:
    // tests/artifacts/Arrays/uint64.py:134
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/uint64.py:134
    // @arc4.abimethod()
    callsub test_allocations
    intc_0 // 1
    return

main_test_array_assignment_maximum_cursage_route@10:
    // tests/artifacts/Arrays/uint64.py:125
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_assignment_maximum_cursage
    intc_0 // 1
    return

main_test_array_evaluation_order_route@9:
    // tests/artifacts/Arrays/uint64.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_evaluation_order
    intc_0 // 1
    return

main_test_array_copy_and_extend_route@8:
    // tests/artifacts/Arrays/uint64.py:84
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_copy_and_extend
    intc_0 // 1
    return

main_test_array_too_long_route@7:
    // tests/artifacts/Arrays/uint64.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_too_long
    intc_0 // 1
    return

main_overhead_route@6:
    // tests/artifacts/Arrays/uint64.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    intc_0 // 1
    return

main_test_array_multiple_append_route@5:
    // tests/artifacts/Arrays/uint64.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_multiple_append
    intc_0 // 1
    return

main_test_array_extend_route@4:
    // tests/artifacts/Arrays/uint64.py:50
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array_extend
    intc_0 // 1
    return

main_test_array_route@3:
    // tests/artifacts/Arrays/uint64.py:14
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_array
    intc_0 // 1
    return

main_bare_routing@17:
    // tests/artifacts/Arrays/uint64.py:13
    // class Contract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@21
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arrays.uint64.quicksort_window(arr: uint64, window_left: uint64, window_right: uint64) -> void:
quicksort_window:
    // tests/artifacts/Arrays/uint64.py:201-204
    // @subroutine
    // def quicksort_window(
    //     arr: ReferenceArray[UInt64], window_left: UInt64, window_right: UInt64
    // ) -> None:
    proto 3 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:207
    // pivot = arr[(window_left + window_right) // 2]
    frame_dig -2
    frame_dig -1
    +
    pushint 2 // 2
    /
    frame_dig -3
    loads
    swap
    intc_1 // 8
    *
    extract_uint64
    frame_dig -1
    frame_dig -2

quicksort_window_while_top@3:
    // tests/artifacts/Arrays/uint64.py:211-212
    // # move left of window towards pivot
    // while arr[left] < pivot:
    frame_dig -3
    loads
    frame_dig 5
    intc_1 // 8
    *
    dup
    frame_bury 0
    extract_uint64
    frame_dig 3
    <
    bz quicksort_window_while_top@6
    // tests/artifacts/Arrays/uint64.py:213
    // left += 1
    frame_dig 5
    intc_0 // 1
    +
    frame_bury 5
    b quicksort_window_while_top@3

quicksort_window_while_top@6:
    // tests/artifacts/Arrays/uint64.py:214-215
    // # move right of window towards pivot
    // while pivot < arr[right]:
    frame_dig -3
    loads
    frame_dig 4
    intc_1 // 8
    *
    dup
    frame_bury 1
    extract_uint64
    frame_dig 3
    >
    bz quicksort_window_after_while@10
    // tests/artifacts/Arrays/uint64.py:216-217
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:219
    // right -= 1
    frame_dig 4
    intc_0 // 1
    -
    frame_bury 4
    b quicksort_window_while_top@6

quicksort_window_after_while@22:
    // tests/artifacts/Arrays/uint64.py:247-248
    // # sort left half of window
    // if window_left < right:
    frame_dig -2
    frame_dig 4
    <
    bz quicksort_window_after_if_else@24
    // tests/artifacts/Arrays/uint64.py:249
    // quicksort_window(arr, window_left, right)
    frame_dig -3
    frame_dig -2
    frame_dig 4
    callsub quicksort_window

quicksort_window_after_if_else@24:
    // tests/artifacts/Arrays/uint64.py:250-251
    // # sort right half of window
    // if left < window_right:
    frame_dig 5
    frame_dig -1
    <
    bz quicksort_window_after_if_else@26
    // tests/artifacts/Arrays/uint64.py:252
    // quicksort_window(arr, left, window_right)
    frame_dig -3
    frame_dig 5
    frame_dig -1
    callsub quicksort_window

quicksort_window_after_if_else@26:
    retsub

quicksort_window_after_while@10:
    // tests/artifacts/Arrays/uint64.py:221-222
    // # if window isn't empty then swap values and move window in
    // if left < right:
    frame_dig 5
    frame_dig 4
    <
    bz quicksort_window_after_if_else@16
    // tests/artifacts/Arrays/uint64.py:223
    // arr[left], arr[right] = arr[right], arr[left]
    frame_dig -3
    loads
    dup
    frame_dig 1
    dup
    cover 3
    intc_1 // 8
    extract3 // on error: index access is out of bounds
    dig 1
    frame_dig 0
    dup
    cover 3
    intc_1 // 8
    extract3 // on error: index access is out of bounds
    cover 3
    replace3
    cover 2
    replace3
    frame_dig -3
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:224
    // left += 1
    frame_dig 5
    intc_0 // 1
    +
    frame_bury 5
    // tests/artifacts/Arrays/uint64.py:225-226
    // # break out of loop if right would go negative
    // if not right:
    frame_dig 4
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:228
    // right -= 1
    frame_dig 4
    intc_0 // 1
    -
    dup
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:229-230
    // # explicit continue to avoid hitting outer break
    // if left <= right:
    frame_dig 5
    >=
    bnz quicksort_window_while_top@3
    b quicksort_window_after_while@22

quicksort_window_after_if_else@16:
    // tests/artifacts/Arrays/uint64.py:235-236
    // # if window is just one item, don't bother swapping, but still adjust window
    // if left == right:
    frame_dig 5
    frame_dig 4
    ==
    bz quicksort_window_after_while@22
    // tests/artifacts/Arrays/uint64.py:237
    // left += 1
    frame_dig 5
    intc_0 // 1
    +
    frame_bury 5
    frame_dig 4
    dup
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:238-239
    // # don't decrement right if it would go negative
    // if right:
    bz quicksort_window_after_if_else@19
    // tests/artifacts/Arrays/uint64.py:240
    // right -= 1
    frame_dig 4
    intc_0 // 1
    -
    frame_bury 2

quicksort_window_after_if_else@19:
    frame_dig 2
    frame_bury 4
    // tests/artifacts/Arrays/uint64.py:241-243
    // # loop always ends in this scenario
    // # and an explict break consumes fewer ops
    // break
    b quicksort_window_after_while@22


// tests.artifacts.Arrays.uint64.create_array() -> uint64:
create_array:
    // tests/artifacts/Arrays/uint64.py:255-256
    // @subroutine(inline=False)
    // def create_array() -> ReferenceArray[UInt64]:
    proto 0 1
    // tests/artifacts/Arrays/uint64.py:257
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:258
    // for i in urange(5):
    intc_2 // 0

create_array_for_header@1:
    // tests/artifacts/Arrays/uint64.py:258
    // for i in urange(5):
    frame_dig 1
    intc_3 // 5
    <
    bz create_array_after_for@4
    // tests/artifacts/Arrays/uint64.py:259
    // arr.append(i)
    frame_dig 0
    dup
    loads
    frame_dig 1
    dup
    cover 3
    itob
    concat // on error: max array length exceeded
    stores
    // tests/artifacts/Arrays/uint64.py:258
    // for i in urange(5):
    intc_0 // 1
    +
    frame_bury 1
    b create_array_for_header@1

create_array_after_for@4:
    // tests/artifacts/Arrays/uint64.py:260
    // return arr
    retsub


// tests.artifacts.Arrays.uint64.assert_last_is_zero(arr: uint64) -> void:
assert_last_is_zero:
    // tests/artifacts/Arrays/uint64.py:263-264
    // @subroutine(inline=False)
    // def assert_last_is_zero(arr: ReferenceArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/uint64.py:265
    // assert arr[arr.length - 1] == 0
    frame_dig -1
    loads
    dup
    len
    intc_1 // 8
    /
    intc_0 // 1
    -
    intc_1 // 8
    *
    extract_uint64
    !
    assert
    retsub


// tests.artifacts.Arrays.uint64.add_x(arr: uint64, x: uint64) -> void:
add_x:
    // tests/artifacts/Arrays/uint64.py:277-278
    // @subroutine
    // def add_x(arr: ReferenceArray[UInt64], x: UInt64) -> None:
    proto 2 0
    // tests/artifacts/Arrays/uint64.py:279
    // for i in urange(x):
    intc_2 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/uint64.py:279
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/uint64.py:280
    // arr.append(i)
    frame_dig -2
    loads
    frame_dig 0
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_dig -2
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:279
    // for i in urange(x):
    intc_0 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.append_length_and_return(arr: uint64) -> uint64:
append_length_and_return:
    // tests/artifacts/Arrays/uint64.py:291-292
    // @subroutine
    // def append_length_and_return(arr: ReferenceArray[UInt64]) -> ReferenceArray[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/uint64.py:293
    // arr.append(arr.length)
    frame_dig -1
    loads
    dup
    len
    intc_1 // 8
    /
    itob
    concat // on error: max array length exceeded
    frame_dig -1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:294
    // return arr
    frame_dig -1
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array() -> void:
test_array:
    // tests/artifacts/Arrays/uint64.py:14-15
    // @arc4.abimethod()
    // def test_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:16
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    // tests/artifacts/Arrays/uint64.py:19
    // arr.append(UInt64(42))
    pushint 42 // 42
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:23
    // add_x(arr, UInt64(5))
    dup
    intc_3 // 5
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:24
    // assert arr.length == 6
    loads
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:25
    // assert arr[-1] == 4
    intc_0 // 1
    -
    intc_1 // 8
    *
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:27
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 4 // 4
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    intc_2 // 0

test_array_for_header@2:
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    frame_dig 2
    // tests/artifacts/Arrays/uint64.py:27
    // pop_x(arr, x=UInt64(3), expected=UInt64(4))
    pushint 3 // 3
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    <
    bz test_array_after_for@4
    // tests/artifacts/Arrays/uint64.py:286
    // popped = arr.pop()
    frame_dig 0
    dup
    loads
    dup
    len
    dup
    intc_1 // 8
    -
    dig 2
    dig 1
    uncover 3
    substring3
    uncover 2
    intc_2 // 0
    uncover 3
    extract3
    swap
    btoi
    cover 2
    stores
    // tests/artifacts/Arrays/uint64.py:287
    // assert popped == expected
    frame_dig 1
    dup
    cover 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:288
    // expected -= 1
    intc_0 // 1
    -
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:285
    // for _i in urange(x):
    frame_dig 2
    intc_0 // 1
    +
    frame_bury 2
    b test_array_for_header@2

test_array_after_for@4:
    // tests/artifacts/Arrays/uint64.py:28
    // assert arr.length == 3
    frame_dig 0
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:29
    // assert arr[-1] == 1
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:31
    // arr.append(UInt64(43))
    pushint 43 // 43
    itob
    concat // on error: max array length exceeded
    dup2
    stores
    // tests/artifacts/Arrays/uint64.py:32
    // assert arr.length == 4
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:33
    // assert arr[-1] == 43
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 43 // 43
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:34
    // assert arr[0] == 42
    intc_2 // 0
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:36
    // add_x(arr, UInt64(10))
    dup
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:37
    // assert arr.length == 14
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:38
    // assert arr[-1] == 9
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:40
    // arr.append(UInt64(44))
    pushint 44 // 44
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:41
    // assert arr.length == 15
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:42
    // assert arr[-1] == 44
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:272
    // arr.append(UInt64(99))
    pushint 99 // 99
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:273
    // arr2.append(UInt64(100))
    pushint 100 // 100
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:44
    // return_ref(arr, arr)[0] += 2
    dup
    intc_2 // 0
    extract_uint64
    pushint 2 // 2
    +
    itob
    replace2 0
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:45
    // assert arr.length == 17
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 17 // 17
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:46
    // assert arr[0] == 44
    dig 1
    intc_2 // 0
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:47
    // assert arr[-2] == 99
    dup
    pushint 2 // 2
    -
    intc_1 // 8
    *
    dig 2
    swap
    extract_uint64
    pushint 99 // 99
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:48
    // assert arr[-1] == 100
    intc_0 // 1
    -
    intc_1 // 8
    *
    extract_uint64
    pushint 100 // 100
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_extend() -> void:
test_array_extend:
    // tests/artifacts/Arrays/uint64.py:52
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:53
    // add_x(arr, UInt64(1))
    dup
    intc_0 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:57
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    pop
    // tests/artifacts/Arrays/uint64.py:59
    // arr.extend(arr2)
    dup
    loads
    // tests/artifacts/Arrays/uint64.py:57
    // arr2.append(UInt64(3))
    bytec_1 // 0x000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/uint64.py:59
    // arr.extend(arr2)
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:60
    // assert arr.length == 4
    len
    intc_1 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_multiple_append() -> void:
test_array_multiple_append:
    // tests/artifacts/Arrays/uint64.py:64
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:65
    // add_x(arr, UInt64(1))
    dup
    intc_0 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:66
    // arr.append(UInt64(1))
    dup
    loads
    intc_0 // 1
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:67
    // arr.append(UInt64(2))
    pushint 2 // 2
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:68
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    concat // on error: max array length exceeded
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:69
    // assert arr.length == 4
    len
    intc_1 // 8
    /
    pushint 4 // 4
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_too_long() -> void:
test_array_too_long:
    // tests/artifacts/Arrays/uint64.py:75-76
    // @arc4.abimethod()
    // def test_array_too_long(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:77
    // array = ReferenceArray[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(512):
    intc_2 // 0

test_array_too_long_for_header@1:
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(512):
    frame_dig 1
    intc 4 // 512
    <
    bz test_array_too_long_after_for@4
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:79
    // array.append(i)
    frame_dig 1
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:78
    // for i in urange(512):
    intc_0 // 1
    +
    frame_bury 1
    b test_array_too_long_for_header@1

test_array_too_long_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:80
    // assert array.length == 512, "array is expected length"
    dup
    len
    intc_1 // 8
    /
    intc 4 // 512
    ==
    assert // array is expected length
    // tests/artifacts/Arrays/uint64.py:82
    // array.append(UInt64(512))  # this will fail
    intc 4 // 512
    itob
    concat // on error: max array length exceeded
    pop
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_copy_and_extend() -> void:
test_array_copy_and_extend:
    // tests/artifacts/Arrays/uint64.py:84-85
    // @arc4.abimethod()
    // def test_array_copy_and_extend(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/uint64.py:86
    // array = ReferenceArray[UInt64]()
    bytec_0 // 0x
    // tests/artifacts/Arrays/uint64.py:87
    // for i in urange(5):
    intc_2 // 0

test_array_copy_and_extend_for_header@1:
    // tests/artifacts/Arrays/uint64.py:87
    // for i in urange(5):
    frame_dig 1
    intc_3 // 5
    <
    bz test_array_copy_and_extend_after_for@4
    frame_dig 0
    // tests/artifacts/Arrays/uint64.py:88
    // array.append(i)
    frame_dig 1
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:87
    // for i in urange(5):
    intc_0 // 1
    +
    frame_bury 1
    b test_array_copy_and_extend_for_header@1

test_array_copy_and_extend_after_for@4:
    frame_dig 0
    dup
    // tests/artifacts/Arrays/uint64.py:91
    // array.append(UInt64(5))
    intc_3 // 5
    itob
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:92
    // assert array.length == 6
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:93
    // assert array[-1] == 5, "expected 5"
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 5
    dig 1
    // tests/artifacts/Arrays/uint64.py:95
    // assert array2.length == 5
    dup
    len
    intc_1 // 8
    /
    dup
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:96
    // assert array2[-1] == 4, "expected 4"
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:98
    // array.extend(array2)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/uint64.py:99
    // assert array.length == 11
    dup
    len
    intc_1 // 8
    /
    dup
    pushint 11 // 11
    ==
    assert
    uncover 2
    // tests/artifacts/Arrays/uint64.py:100
    // assert array2.length == 5
    len
    intc_1 // 8
    /
    intc_3 // 5
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:101
    // assert array[-1] == 4, "expected 4"
    intc_0 // 1
    -
    intc_1 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:102
    // assert array[4] == 4, "expected 4"
    dup
    pushint 32 // 32
    extract_uint64
    pushint 4 // 4
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:103
    // assert array[5] == 5, "expected 4"
    dup
    pushint 40 // 40
    extract_uint64
    intc_3 // 5
    ==
    assert // expected 4
    // tests/artifacts/Arrays/uint64.py:104
    // assert array[6] == 0, "expected 4"
    pushint 48 // 48
    extract_uint64
    !
    assert // expected 4
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_evaluation_order() -> void:
test_array_evaluation_order:
    // tests/artifacts/Arrays/uint64.py:108
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    // tests/artifacts/Arrays/uint64.py:109
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:110
    // append_length_and_return(arr).extend(append_length_and_return(arr))
    dup
    callsub append_length_and_return
    dig 1
    callsub append_length_and_return
    loads
    dig 1
    loads
    swap
    concat // on error: max array length exceeded
    stores
    // tests/artifacts/Arrays/uint64.py:111
    // assert arr.length == 6
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:112
    // assert arr[0] == 3
    dup
    intc_2 // 0
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:113
    // assert arr[1] == 1
    dup
    intc_1 // 8
    extract_uint64
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:114
    // assert arr[2] == 2
    dup
    pushint 16 // 16
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:115
    // assert arr[3] == 3
    dup
    pushint 24 // 24
    extract_uint64
    pushint 3 // 3
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:116
    // assert arr[4] == 1
    dup
    pushint 32 // 32
    extract_uint64
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:117
    // assert arr[5] == 2
    pushint 40 // 40
    extract_uint64
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:119
    // arr[append_length_and_return(arr)[0]] = append_length_and_return(arr)[-1]
    dup
    callsub append_length_and_return
    loads
    dup
    len
    intc_1 // 8
    /
    intc_0 // 1
    -
    intc_1 // 8
    *
    intc_1 // 8
    extract3 // on error: index access is out of bounds
    dig 1
    callsub append_length_and_return
    loads
    intc_2 // 0
    extract_uint64
    dig 2
    loads
    swap
    intc_1 // 8
    *
    uncover 2
    replace3
    swap
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:120
    // assert arr.length == 8
    dup
    len
    intc_1 // 8
    /
    intc_1 // 8
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:121
    // assert arr[6] == 6
    dup
    pushint 48 // 48
    extract_uint64
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:122
    // assert arr[7] == 7
    dup
    pushint 56 // 56
    extract_uint64
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:123
    // assert arr[3] == 6
    pushint 24 // 24
    extract_uint64
    pushint 6 // 6
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_array_assignment_maximum_cursage() -> void:
test_array_assignment_maximum_cursage:
    // tests/artifacts/Arrays/uint64.py:127
    // arr = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    // tests/artifacts/Arrays/uint64.py:128
    // arr.append(UInt64(3))
    pushint 3 // 3
    itob
    dig 1
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:129
    // append_length_and_return(arr)[0] = UInt64(42)
    dup
    callsub append_length_and_return
    pushint 42 // 42
    itob
    dig 1
    loads
    swap
    replace2 0
    stores
    // tests/artifacts/Arrays/uint64.py:130
    // assert arr.length == 2
    loads
    dup
    len
    intc_1 // 8
    /
    pushint 2 // 2
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:131
    // assert arr[0] == 42
    dup
    intc_2 // 0
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:132
    // assert arr[1] == 1
    intc_1 // 8
    extract_uint64
    intc_0 // 1
    ==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_allocations(num: uint64) -> void:
test_allocations:
    // tests/artifacts/Arrays/uint64.py:134-135
    // @arc4.abimethod()
    // def test_allocations(self, num: UInt64) -> None:
    proto 1 0
    // tests/artifacts/Arrays/uint64.py:136
    // for _i in urange(num):
    intc_2 // 0

test_allocations_for_header@1:
    // tests/artifacts/Arrays/uint64.py:136
    // for _i in urange(num):
    frame_dig 0
    frame_dig -1
    <
    bz test_allocations_after_for@4
    // tests/artifacts/Arrays/uint64.py:137
    // alloc_test = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:138
    // add_x(alloc_test, UInt64(1))
    intc_0 // 1
    callsub add_x
    // tests/artifacts/Arrays/uint64.py:136
    // for _i in urange(num):
    frame_dig 0
    intc_0 // 1
    +
    frame_bury 0
    b test_allocations_for_header@1

test_allocations_after_for@4:
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_iteration() -> void:
test_iteration:
    // tests/artifacts/Arrays/uint64.py:140-141
    // @arc4.abimethod()
    // def test_iteration(self) -> None:
    proto 0 0
    intc_2 // 0
    dup
    bytec_0 // ""
    // tests/artifacts/Arrays/uint64.py:142
    // arr = ReferenceArray[UInt64]()
    dupn 7
    // tests/artifacts/Arrays/uint64.py:143
    // for val in urange(5):
    intc_2 // 0

test_iteration_for_header@1:
    // tests/artifacts/Arrays/uint64.py:143
    // for val in urange(5):
    frame_dig 10
    intc_3 // 5
    <
    bz test_iteration_after_for@4
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:144
    // arr.append(val)
    frame_dig 10
    dup
    cover 2
    itob
    concat // on error: max array length exceeded
    frame_bury 9
    // tests/artifacts/Arrays/uint64.py:143
    // for val in urange(5):
    intc_0 // 1
    +
    frame_bury 10
    b test_iteration_for_header@1

test_iteration_after_for@4:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:145
    // assert arr.length == 5, "expected array of length 5"
    len
    intc_1 // 8
    /
    dup
    frame_bury 2
    intc_3 // 5
    ==
    assert // expected array of length 5
    // tests/artifacts/Arrays/uint64.py:147-148
    // # iterate
    // last = UInt64(0)
    intc_2 // 0
    frame_bury 7
    intc_2 // 0
    frame_bury 6

test_iteration_for_header@5:
    // tests/artifacts/Arrays/uint64.py:149
    // for value in arr:
    frame_dig 6
    frame_dig 2
    <
    bz test_iteration_after_for@8
    frame_dig 9
    frame_dig 6
    dup
    cover 2
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:150
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 7
    >=
    assert // array is not sorted
    swap
    intc_0 // 1
    +
    frame_bury 6
    frame_bury 7
    b test_iteration_for_header@5

test_iteration_after_for@8:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:153-154
    // # enumerate
    // for idx, value in uenumerate(arr):
    len
    intc_1 // 8
    /
    frame_bury 3
    intc_2 // 0
    frame_bury 5

test_iteration_for_header@9:
    // tests/artifacts/Arrays/uint64.py:153-154
    // # enumerate
    // for idx, value in uenumerate(arr):
    frame_dig 5
    frame_dig 3
    <
    bz test_iteration_after_for@12
    frame_dig 9
    frame_dig 5
    dup
    cover 2
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:155
    // assert value == idx, "incorrect array value"
    dig 1
    ==
    assert // incorrect array value
    intc_0 // 1
    +
    frame_bury 5
    b test_iteration_for_header@9

test_iteration_after_for@12:
    frame_dig 9
    // tests/artifacts/Arrays/uint64.py:157-158
    // # reverse
    // for value in reversed(arr):
    len
    intc_1 // 8
    /
    frame_bury 8

test_iteration_for_header@13:
    // tests/artifacts/Arrays/uint64.py:157-158
    // # reverse
    // for value in reversed(arr):
    frame_dig 8
    bz test_iteration_after_for@16
    frame_dig 8
    intc_0 // 1
    -
    dup
    frame_bury 8
    frame_dig 9
    swap
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:159
    // assert value <= last, "array is not sorted"
    dup
    frame_dig 7
    <=
    assert // array is not sorted
    frame_bury 7
    b test_iteration_for_header@13

test_iteration_after_for@16:
    // tests/artifacts/Arrays/uint64.py:162
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    pushbytes 0x0000
    frame_bury 0
    // tests/artifacts/Arrays/uint64.py:142
    // arr = ReferenceArray[UInt64]()
    bytec_0 // 0x
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:164
    // for i in urange(5):
    intc_2 // 0
    frame_bury 4

test_iteration_for_header@17:
    // tests/artifacts/Arrays/uint64.py:164
    // for i in urange(5):
    frame_dig 4
    intc_3 // 5
    <
    bz test_iteration_after_for@20
    // tests/artifacts/Arrays/uint64.py:165
    // arc4_arr.append(arc4.UInt64(i))
    frame_dig 4
    dup
    itob
    frame_dig 0
    dup
    cover 2
    dig 1
    concat // on error: max array length exceeded
    uncover 2
    intc_2 // 0
    extract_uint16
    intc_0 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    frame_dig 1
    // tests/artifacts/Arrays/uint64.py:166
    // native_arr.append(arc4.UInt64(i))
    swap
    concat // on error: max array length exceeded
    frame_bury 1
    // tests/artifacts/Arrays/uint64.py:164
    // for i in urange(5):
    intc_0 // 1
    +
    frame_bury 4
    b test_iteration_for_header@17

test_iteration_after_for@20:
    // tests/artifacts/Arrays/uint64.py:167
    // combined_arr = arc4_arr + native_arr
    frame_dig 0
    frame_dig 1
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_1 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/uint64.py:168
    // assert combined_arr.length == 10
    dup
    intc_2 // 0
    extract_uint16
    pushint 10 // 10
    ==
    assert
    // tests/artifacts/Arrays/uint64.py:169
    // assert combined_arr[0] == 0
    dup
    extract 2 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:170
    // assert combined_arr[4] == 4
    dup
    extract 34 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:171
    // assert combined_arr[5] == 0
    dup
    extract 42 8
    bytec_2 // 0x0000000000000000
    b==
    assert
    // tests/artifacts/Arrays/uint64.py:172
    // assert combined_arr[9] == 4
    extract 74 8
    bytec_3 // 0x0000000000000004
    b==
    assert
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_quicksort() -> void:
test_quicksort:
    // tests/artifacts/Arrays/uint64.py:174-175
    // @arc4.abimethod()
    // def test_quicksort(self) -> None:
    proto 0 0
    bytec_0 // ""
    dupn 2
    // tests/artifacts/Arrays/uint64.py:176-177
    // # create pseudo random array from sender address
    // rnd = ReferenceArray[UInt64]()
    callsub _puya_lib.mem.new_slot
    dup
    bytec_0 // 0x
    stores
    // tests/artifacts/Arrays/uint64.py:178
    // for b in Txn.sender.bytes:
    txn Sender
    intc_2 // 0

test_quicksort_for_header@1:
    // tests/artifacts/Arrays/uint64.py:178
    // for b in Txn.sender.bytes:
    frame_dig 5
    pushint 32 // 32
    <
    bz test_quicksort_after_for@4
    // tests/artifacts/Arrays/uint64.py:179
    // rnd.append(op.btoi(b))
    frame_dig 4
    frame_dig 5
    dup
    cover 2
    getbyte
    frame_dig 3
    dup
    cover 2
    loads
    swap
    itob
    concat // on error: max array length exceeded
    stores
    intc_0 // 1
    +
    frame_bury 5
    b test_quicksort_for_header@1

test_quicksort_after_for@4:
    // tests/artifacts/Arrays/uint64.py:180
    // assert rnd.length == 32, "expected array of length 32"
    frame_dig 3
    dup
    loads
    len
    intc_1 // 8
    /
    dup
    pushint 32 // 32
    ==
    assert // expected array of length 32
    // tests/artifacts/Arrays/uint64.py:182-183
    // # sort the array
    // quicksort_window(rnd, UInt64(0), rnd.length - 1)
    intc_0 // 1
    -
    dig 1
    intc_2 // 0
    uncover 2
    callsub quicksort_window
    // tests/artifacts/Arrays/uint64.py:185-186
    // # array should now be in ascending order
    // last = UInt64(0)
    intc_2 // 0
    frame_bury 2
    // tests/artifacts/Arrays/uint64.py:187
    // for value in rnd:
    loads
    len
    intc_1 // 8
    /
    frame_bury 0
    intc_2 // 0
    frame_bury 1

test_quicksort_for_header@5:
    // tests/artifacts/Arrays/uint64.py:187
    // for value in rnd:
    frame_dig 1
    frame_dig 0
    <
    bz test_quicksort_after_for@8
    frame_dig 3
    loads
    frame_dig 1
    dup
    cover 2
    intc_1 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/uint64.py:188
    // assert value >= last, "array is not sorted"
    dup
    frame_dig 2
    >=
    assert // array is not sorted
    swap
    intc_0 // 1
    +
    frame_bury 1
    frame_bury 2
    b test_quicksort_for_header@5

test_quicksort_after_for@8:
    retsub


// tests.artifacts.Arrays.uint64.Contract.test_unobserved_write() -> void:
test_unobserved_write:
    // tests/artifacts/Arrays/uint64.py:193
    // arr = create_array()
    callsub create_array
    // tests/artifacts/Arrays/uint64.py:194
    // last = arr.length - 1
    dup
    loads
    dup
    len
    intc_1 // 8
    /
    intc_0 // 1
    -
    // tests/artifacts/Arrays/uint64.py:195
    // arr[last] = UInt64(0)  # write
    intc_2 // 0
    itob
    swap
    intc_1 // 8
    *
    uncover 2
    dig 1
    uncover 3
    replace3
    dig 2
    swap
    stores
    // tests/artifacts/Arrays/uint64.py:196
    // assert_last_is_zero(arr)
    dig 1
    callsub assert_last_is_zero
    // tests/artifacts/Arrays/uint64.py:197
    // arr[last] = UInt64(1)  # write
    intc_0 // 1
    itob
    dig 2
    loads
    dig 2
    uncover 2
    replace3
    uncover 2
    dig 1
    stores
    // tests/artifacts/Arrays/uint64.py:198
    // assert arr[last] == 1
    swap
    extract_uint64
    intc_0 // 1
    ==
    assert
    retsub


// _puya_lib.mem.new_slot() -> uint64:
_puya_lib.mem.new_slot:
    load 0
    bitlen
    load 0
    pushint 256 // 256
    dig 2
    -
    intc_2 // 0
    setbit // on error: no available slots
    store 0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "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",
+        "approval": "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",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal b/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal
index 28edb37d..43ddf9c7 100644
--- a/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal
+++ b/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal
@@ -4,52 +4,89 @@
 // algopy.arc4.ARC4Contract.approval_program() -> uint64:
 main:
     intcblock 0 1 2 8
-    bytecblock 0x00 0x151f7c75 0x 0x0000 0x0002 0x80 0x000a 0x00000000000000010000000000000002 0x000161000162
-    // tests/artifacts/Arrays/immutable.py:74
+    bytecblock 0x151f7c75 0x 0x0000 0x00 0x0002 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0x000a 0x62696775696e74 0x000200000000000000010000000000000002 0x000200040007000161000162 "imm_fixed_arr"
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@26
-    pushbytess 0x44d42f99 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f // method "test_uint64_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]"
+    bz main_bare_routing@29
+    pushbytess 0x44d42f99 0xb7eaa60b 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f 0x6d4aa358 0xb7cb96bd // method "test_uint64_array()void", method "test_biguint_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]", method "test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]", method "test_imm_fixed_arr()(uint64,uint64)[3]"
     txna ApplicationArgs 0
-    match main_test_uint64_array_route@3 main_test_bool_array_route@4 main_test_fixed_size_tuple_array_route@5 main_test_fixed_size_named_tuple_array_route@6 main_test_dynamic_sized_tuple_array_route@7 main_test_dynamic_sized_named_tuple_array_route@8 main_test_implicit_conversion_log_route@9 main_test_implicit_conversion_emit_route@10 main_test_nested_array_route@11 main_test_bit_packed_tuples_route@12 main_sum_uints_and_lengths_and_trues_route@13 main_test_uint64_return_route@14 main_test_bool_return_route@15 main_test_tuple_return_route@16 main_test_dynamic_tuple_return_route@17 main_test_convert_to_array_and_back_route@18 main_test_concat_with_arc4_tuple_route@19 main_test_concat_with_native_tuple_route@20 main_test_dynamic_concat_with_arc4_tuple_route@21 main_test_dynamic_concat_with_native_tuple_route@22 main_test_concat_immutable_dynamic_route@23
+    match main_test_uint64_array_route@3 main_test_biguint_array_route@4 main_test_bool_array_route@5 main_test_fixed_size_tuple_array_route@6 main_test_fixed_size_named_tuple_array_route@7 main_test_dynamic_sized_tuple_array_route@8 main_test_dynamic_sized_named_tuple_array_route@9 main_test_implicit_conversion_log_route@10 main_test_implicit_conversion_emit_route@11 main_test_nested_array_route@12 main_test_bit_packed_tuples_route@13 main_sum_uints_and_lengths_and_trues_route@14 main_test_uint64_return_route@15 main_test_bool_return_route@16 main_test_tuple_return_route@17 main_test_dynamic_tuple_return_route@18 main_test_convert_to_array_and_back_route@19 main_test_concat_with_arc4_tuple_route@20 main_test_concat_with_native_tuple_route@21 main_test_dynamic_concat_with_arc4_tuple_route@22 main_test_dynamic_concat_with_native_tuple_route@23 main_test_concat_immutable_dynamic_route@24 main_test_immutable_arc4_route@25 main_test_imm_fixed_arr_route@26
 
-main_after_if_else@30:
-    // tests/artifacts/Arrays/immutable.py:74
+main_after_if_else@33:
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     intc_0 // 0
     return
 
-main_test_concat_immutable_dynamic_route@23:
-    // tests/artifacts/Arrays/immutable.py:394
+main_test_imm_fixed_arr_route@26:
+    // tests/artifacts/Arrays/immutable.py:450
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub test_imm_fixed_arr
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_1 // 1
+    return
+
+main_test_immutable_arc4_route@25:
+    // tests/artifacts/Arrays/immutable.py:444
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    // tests/artifacts/Arrays/immutable.py:93
+    // class ImmutableArrayContract(arc4.ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/Arrays/immutable.py:444
+    // @arc4.abimethod()
+    callsub test_immutable_arc4
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_1 // 1
+    return
+
+main_test_concat_immutable_dynamic_route@24:
+    // tests/artifacts/Arrays/immutable.py:438
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
-    // tests/artifacts/Arrays/immutable.py:394
+    // tests/artifacts/Arrays/immutable.py:438
     // @arc4.abimethod()
     callsub test_concat_immutable_dynamic
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_dynamic_concat_with_native_tuple_route@22:
-    // tests/artifacts/Arrays/immutable.py:386
+main_test_dynamic_concat_with_native_tuple_route@23:
+    // tests/artifacts/Arrays/immutable.py:430
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     dup
@@ -68,235 +105,231 @@ main_test_dynamic_concat_with_native_tuple_route@22:
     uncover 3
     uncover 2
     substring3
-    // tests/artifacts/Arrays/immutable.py:386
+    // tests/artifacts/Arrays/immutable.py:430
     // @arc4.abimethod()
     callsub test_dynamic_concat_with_native_tuple
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_dynamic_concat_with_arc4_tuple_route@21:
-    // tests/artifacts/Arrays/immutable.py:378
+main_test_dynamic_concat_with_arc4_tuple_route@22:
+    // tests/artifacts/Arrays/immutable.py:422
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/Arrays/immutable.py:378
+    // tests/artifacts/Arrays/immutable.py:422
     // @arc4.abimethod()
     callsub test_dynamic_concat_with_arc4_tuple
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_concat_with_native_tuple_route@20:
-    // tests/artifacts/Arrays/immutable.py:370
+main_test_concat_with_native_tuple_route@21:
+    // tests/artifacts/Arrays/immutable.py:414
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     dup
-    extract 0 8 // on error: Index access is out of bounds
+    extract 0 8
     swap
-    extract 8 8 // on error: Index access is out of bounds
-    // tests/artifacts/Arrays/immutable.py:370
+    extract 8 8
+    // tests/artifacts/Arrays/immutable.py:414
     // @arc4.abimethod()
     callsub test_concat_with_native_tuple
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_concat_with_arc4_tuple_route@19:
-    // tests/artifacts/Arrays/immutable.py:362
+main_test_concat_with_arc4_tuple_route@20:
+    // tests/artifacts/Arrays/immutable.py:406
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/Arrays/immutable.py:362
+    // tests/artifacts/Arrays/immutable.py:406
     // @arc4.abimethod()
     callsub test_concat_with_arc4_tuple
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_convert_to_array_and_back_route@18:
-    // tests/artifacts/Arrays/immutable.py:352
+main_test_convert_to_array_and_back_route@19:
+    // tests/artifacts/Arrays/immutable.py:396
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/Arrays/immutable.py:352
+    // tests/artifacts/Arrays/immutable.py:396
     // @arc4.abimethod()
     callsub test_convert_to_array_and_back
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_dynamic_tuple_return_route@17:
-    // tests/artifacts/Arrays/immutable.py:345
+main_test_dynamic_tuple_return_route@18:
+    // tests/artifacts/Arrays/immutable.py:389
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/immutable.py:345
+    // tests/artifacts/Arrays/immutable.py:389
     // @arc4.abimethod()
     callsub test_dynamic_tuple_return
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_tuple_return_route@16:
-    // tests/artifacts/Arrays/immutable.py:338
+main_test_tuple_return_route@17:
+    // tests/artifacts/Arrays/immutable.py:382
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/immutable.py:338
+    // tests/artifacts/Arrays/immutable.py:382
     // @arc4.abimethod()
     callsub test_tuple_return
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_bool_return_route@15:
-    // tests/artifacts/Arrays/immutable.py:331
+main_test_bool_return_route@16:
+    // tests/artifacts/Arrays/immutable.py:375
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/immutable.py:331
+    // tests/artifacts/Arrays/immutable.py:375
     // @arc4.abimethod()
     callsub test_bool_return
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_uint64_return_route@14:
-    // tests/artifacts/Arrays/immutable.py:324
+main_test_uint64_return_route@15:
+    // tests/artifacts/Arrays/immutable.py:368
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/immutable.py:324
+    // tests/artifacts/Arrays/immutable.py:368
     // @arc4.abimethod()
     callsub test_uint64_return
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_sum_uints_and_lengths_and_trues_route@13:
-    // tests/artifacts/Arrays/immutable.py:297
+main_sum_uints_and_lengths_and_trues_route@14:
+    // tests/artifacts/Arrays/immutable.py:341
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
     txna ApplicationArgs 3
     txna ApplicationArgs 4
-    // tests/artifacts/Arrays/immutable.py:297
+    // tests/artifacts/Arrays/immutable.py:341
     // @arc4.abimethod()
     callsub sum_uints_and_lengths_and_trues
     uncover 3
     itob
     uncover 3
     itob
-    uncover 3
-    itob
-    uncover 3
-    itob
-    uncover 3
-    uncover 3
     concat
     uncover 2
+    itob
     concat
     swap
+    itob
     concat
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_bit_packed_tuples_route@12:
-    // tests/artifacts/Arrays/immutable.py:232
+main_test_bit_packed_tuples_route@13:
+    // tests/artifacts/Arrays/immutable.py:276
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -307,65 +340,65 @@ main_test_bit_packed_tuples_route@12:
     intc_1 // 1
     return
 
-main_test_nested_array_route@11:
-    // tests/artifacts/Arrays/immutable.py:214
+main_test_nested_array_route@12:
+    // tests/artifacts/Arrays/immutable.py:258
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txna ApplicationArgs 2
-    // tests/artifacts/Arrays/immutable.py:214
+    // tests/artifacts/Arrays/immutable.py:258
     // @arc4.abimethod()
     callsub test_nested_array
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
     intc_1 // 1
     return
 
-main_test_implicit_conversion_emit_route@10:
-    // tests/artifacts/Arrays/immutable.py:210
+main_test_implicit_conversion_emit_route@11:
+    // tests/artifacts/Arrays/immutable.py:254
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/Arrays/immutable.py:210
+    // tests/artifacts/Arrays/immutable.py:254
     // @arc4.abimethod()
     callsub test_implicit_conversion_emit
     intc_1 // 1
     return
 
-main_test_implicit_conversion_log_route@9:
-    // tests/artifacts/Arrays/immutable.py:206
+main_test_implicit_conversion_log_route@10:
+    // tests/artifacts/Arrays/immutable.py:250
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/Arrays/immutable.py:206
+    // tests/artifacts/Arrays/immutable.py:250
     // @arc4.abimethod()
     callsub test_implicit_conversion_log
     intc_1 // 1
     return
 
-main_test_dynamic_sized_named_tuple_array_route@8:
-    // tests/artifacts/Arrays/immutable.py:187
+main_test_dynamic_sized_named_tuple_array_route@9:
+    // tests/artifacts/Arrays/immutable.py:231
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -376,8 +409,8 @@ main_test_dynamic_sized_named_tuple_array_route@8:
     intc_1 // 1
     return
 
-main_test_dynamic_sized_tuple_array_route@7:
-    // tests/artifacts/Arrays/immutable.py:168
+main_test_dynamic_sized_tuple_array_route@8:
+    // tests/artifacts/Arrays/immutable.py:212
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -388,8 +421,8 @@ main_test_dynamic_sized_tuple_array_route@7:
     intc_1 // 1
     return
 
-main_test_fixed_size_named_tuple_array_route@6:
-    // tests/artifacts/Arrays/immutable.py:153
+main_test_fixed_size_named_tuple_array_route@7:
+    // tests/artifacts/Arrays/immutable.py:197
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -400,8 +433,8 @@ main_test_fixed_size_named_tuple_array_route@6:
     intc_1 // 1
     return
 
-main_test_fixed_size_tuple_array_route@5:
-    // tests/artifacts/Arrays/immutable.py:135
+main_test_fixed_size_tuple_array_route@6:
+    // tests/artifacts/Arrays/immutable.py:179
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -412,26 +445,38 @@ main_test_fixed_size_tuple_array_route@5:
     intc_1 // 1
     return
 
-main_test_bool_array_route@4:
-    // tests/artifacts/Arrays/immutable.py:111
+main_test_bool_array_route@5:
+    // tests/artifacts/Arrays/immutable.py:155
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/immutable.py:74
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/immutable.py:111
+    // tests/artifacts/Arrays/immutable.py:155
     // @arc4.abimethod()
     callsub test_bool_array
     intc_1 // 1
     return
 
+main_test_biguint_array_route@4:
+    // tests/artifacts/Arrays/immutable.py:130
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub test_biguint_array
+    intc_1 // 1
+    return
+
 main_test_uint64_array_route@3:
-    // tests/artifacts/Arrays/immutable.py:75
+    // tests/artifacts/Arrays/immutable.py:94
     // @arc4.abimethod()
     txn OnCompletion
     !
@@ -442,11 +487,11 @@ main_test_uint64_array_route@3:
     intc_1 // 1
     return
 
-main_bare_routing@26:
-    // tests/artifacts/Arrays/immutable.py:74
+main_bare_routing@29:
+    // tests/artifacts/Arrays/immutable.py:93
     // class ImmutableArrayContract(arc4.ARC4Contract):
     txn OnCompletion
-    bnz main_after_if_else@30
+    bnz main_after_if_else@33
     txn ApplicationID
     !
     assert // can only call when creating
@@ -507,7 +552,7 @@ dynamic_array_pop_dynamic_element:
     swap
     cover 2
     substring3
-    bytec_2 // 0x
+    bytec_1 // 0x
     intc_0 // 0
 
 dynamic_array_pop_dynamic_element_for_header@1:
@@ -556,7 +601,7 @@ dynamic_array_pop_dynamic_element_after_for@4:
 // _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
 dynamic_array_concat_bits:
     proto 4 1
-    bytec_2 // ""
+    bytec_1 // ""
     dupn 2
     frame_dig -4
     intc_0 // 0
@@ -689,7 +734,7 @@ dynamic_array_concat_byte_length_head_for_header@2:
     frame_dig 3
     frame_dig 2
     <
-    bz dynamic_array_concat_byte_length_head_after_for@5
+    bz dynamic_array_concat_byte_length_head_after_for@4
     frame_dig 4
     dup
     itob
@@ -713,7 +758,7 @@ dynamic_array_concat_byte_length_head_for_header@2:
     frame_bury 3
     b dynamic_array_concat_byte_length_head_for_header@2
 
-dynamic_array_concat_byte_length_head_after_for@5:
+dynamic_array_concat_byte_length_head_after_for@4:
     frame_dig 0
     frame_dig 1
     concat
@@ -724,7 +769,7 @@ dynamic_array_concat_byte_length_head_after_for@5:
 // _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
 dynamic_array_concat_dynamic_element:
     proto 4 1
-    bytec_2 // ""
+    bytec_1 // ""
     dup
     frame_dig -2
     intc_2 // 2
@@ -811,33 +856,92 @@ dynamic_array_concat_dynamic_element_after_for@8:
     retsub
 
 
+// tests.artifacts.Arrays.immutable.sum_imm_fixed(arr: bytes) -> uint64:
+sum_imm_fixed:
+    // tests/artifacts/Arrays/immutable.py:479-480
+    // @subroutine
+    // def sum_imm_fixed(arr: NativeStruct3) -> UInt64:
+    proto 1 1
+    // tests/artifacts/Arrays/immutable.py:481
+    // total = UInt64(0)
+    intc_0 // 0
+    dup
+
+sum_imm_fixed_for_header@1:
+    // tests/artifacts/Arrays/immutable.py:482
+    // for item in arr:
+    frame_dig 1
+    pushint 3 // 3
+    <
+    bz sum_imm_fixed_after_for@4
+    // tests/artifacts/Arrays/immutable.py:482-483
+    // for item in arr:
+    //     total += item.foo
+    frame_dig 1
+    dup
+    pushint 16 // 16
+    *
+    frame_dig -1
+    swap
+    pushint 16 // 16
+    extract3 // on error: index access is out of bounds
+    // tests/artifacts/Arrays/immutable.py:483
+    // total += item.foo
+    dup
+    // tests/artifacts/Arrays/immutable.py:482-483
+    // for item in arr:
+    //     total += item.foo
+    intc_0 // 0
+    // tests/artifacts/Arrays/immutable.py:483
+    // total += item.foo
+    extract_uint64
+    frame_dig 0
+    +
+    // tests/artifacts/Arrays/immutable.py:484
+    // total += item.bar
+    swap
+    intc_3 // 8
+    extract_uint64
+    +
+    frame_bury 0
+    intc_1 // 1
+    +
+    frame_bury 1
+    b sum_imm_fixed_for_header@1
+
+sum_imm_fixed_after_for@4:
+    // tests/artifacts/Arrays/immutable.py:485
+    // return total
+    retsub
+
+
 // tests.artifacts.Arrays.immutable.times(n: uint64) -> bytes:
 times:
-    // tests/artifacts/Arrays/immutable.py:401-402
+    // tests/artifacts/Arrays/immutable.py:488-489
     // @subroutine
     // def times(n: UInt64) -> String:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:403
+    // tests/artifacts/Arrays/immutable.py:490
     // result = String()
-    bytec_2 // ""
-    // tests/artifacts/Arrays/immutable.py:404
+    bytec_1 // ""
+    // tests/artifacts/Arrays/immutable.py:491
     // for _i in urange(n):
     intc_0 // 0
 
 times_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:404
+    // tests/artifacts/Arrays/immutable.py:491
     // for _i in urange(n):
     frame_dig 1
     frame_dig -1
     <
     bz times_after_for@4
-    // tests/artifacts/Arrays/immutable.py:405
+    // tests/artifacts/Arrays/immutable.py:492
     // result += String(" ")
     frame_dig 0
     pushbytes " "
     concat
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:404
+    // tests/artifacts/Arrays/immutable.py:491
     // for _i in urange(n):
     frame_dig 1
     intc_1 // 1
@@ -846,47 +950,46 @@ times_for_header@1:
     b times_for_header@1
 
 times_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:406
+    // tests/artifacts/Arrays/immutable.py:493
     // return result
     retsub
 
 
 // tests.artifacts.Arrays.immutable.add_x(arr: bytes, x: uint64) -> bytes:
 add_x:
-    // tests/artifacts/Arrays/immutable.py:409-410
+    // tests/artifacts/Arrays/immutable.py:496-497
     // @subroutine
     // def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
     proto 2 1
-    // tests/artifacts/Arrays/immutable.py:411
+    // tests/artifacts/Arrays/immutable.py:498
     // for i in urange(x):
     intc_0 // 0
 
 add_x_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:411
+    // tests/artifacts/Arrays/immutable.py:498
     // for i in urange(x):
     frame_dig 0
     frame_dig -1
     <
     bz add_x_after_for@4
-    // tests/artifacts/Arrays/immutable.py:412
+    // tests/artifacts/Arrays/immutable.py:499
     // arr = arr.append(i)
-    frame_dig -2
-    extract 2 0
     frame_dig 0
     dup
-    cover 2
     itob
-    concat
-    dup
-    len
-    intc_3 // 8
-    /
+    frame_dig -2
+    swap
+    concat // on error: max array length exceeded
+    frame_dig -2
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury -2
-    // tests/artifacts/Arrays/immutable.py:411
+    // tests/artifacts/Arrays/immutable.py:498
     // for i in urange(x):
     intc_1 // 1
     +
@@ -894,7 +997,7 @@ add_x_for_header@1:
     b add_x_for_header@1
 
 add_x_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:413
+    // tests/artifacts/Arrays/immutable.py:500
     // return arr
     frame_dig -2
     swap
@@ -903,18 +1006,18 @@ add_x_after_for@4:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_array() -> void:
 test_uint64_array:
-    // tests/artifacts/Arrays/immutable.py:75-76
+    // tests/artifacts/Arrays/immutable.py:94-95
     // @arc4.abimethod()
     // def test_uint64_array(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/immutable.py:80
+    // tests/artifacts/Arrays/immutable.py:99
     // arr = arr.append(UInt64(42))
     pushbytes 0x0001000000000000002a
-    // tests/artifacts/Arrays/immutable.py:84
+    // tests/artifacts/Arrays/immutable.py:103
     // arr = add_x(arr, UInt64(5))
     pushint 5 // 5
     callsub add_x
-    // tests/artifacts/Arrays/immutable.py:85
+    // tests/artifacts/Arrays/immutable.py:104
     // assert arr.length == 6
     dup
     intc_0 // 0
@@ -923,36 +1026,35 @@ test_uint64_array:
     pushint 6 // 6
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:86
+    // tests/artifacts/Arrays/immutable.py:105
     // assert arr[-1] == 4
+    dup
     intc_1 // 1
     -
-    swap
+    dig 2
     extract 2 0
     swap
     intc_3 // 8
     *
-    dig 1
-    swap
     extract_uint64
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:88
+    // tests/artifacts/Arrays/immutable.py:107
     // arr = arr.append(UInt64(43))
     pushint 43 // 43
     itob
-    concat
-    dup
-    len
-    intc_3 // 8
-    /
+    uncover 2
+    swap
+    concat // on error: max array length exceeded
+    swap
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     dupn 2
-    // tests/artifacts/Arrays/immutable.py:89
+    // tests/artifacts/Arrays/immutable.py:108
     // assert arr.length == 7
     intc_0 // 0
     extract_uint16
@@ -960,7 +1062,7 @@ test_uint64_array:
     pushint 7 // 7
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:90
+    // tests/artifacts/Arrays/immutable.py:109
     // assert arr[-1] == 43
     intc_1 // 1
     -
@@ -974,35 +1076,35 @@ test_uint64_array:
     ==
     assert
     intc_2 // 2
-    // tests/artifacts/Arrays/immutable.py:91
+    // tests/artifacts/Arrays/immutable.py:110
     // assert arr[0] == 42
     extract_uint64
     pushint 42 // 42
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:418
+    // tests/artifacts/Arrays/immutable.py:505
     // for _i in urange(x):
     intc_0 // 0
 
 test_uint64_array_for_header@2:
-    // tests/artifacts/Arrays/immutable.py:418
+    // tests/artifacts/Arrays/immutable.py:505
     // for _i in urange(x):
     frame_dig 1
-    // tests/artifacts/Arrays/immutable.py:93
+    // tests/artifacts/Arrays/immutable.py:112
     // arr = pop_x(arr, UInt64(3))
     pushint 3 // 3
-    // tests/artifacts/Arrays/immutable.py:418
+    // tests/artifacts/Arrays/immutable.py:505
     // for _i in urange(x):
     <
     bz test_uint64_array_after_for@4
-    // tests/artifacts/Arrays/immutable.py:419
+    // tests/artifacts/Arrays/immutable.py:506
     // arr = arr.pop()
     frame_dig 0
     intc_3 // 8
     callsub dynamic_array_pop_fixed_size
     frame_bury 0
     pop
-    // tests/artifacts/Arrays/immutable.py:418
+    // tests/artifacts/Arrays/immutable.py:505
     // for _i in urange(x):
     frame_dig 1
     intc_1 // 1
@@ -1011,7 +1113,7 @@ test_uint64_array_for_header@2:
     b test_uint64_array_for_header@2
 
 test_uint64_array_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:94
+    // tests/artifacts/Arrays/immutable.py:113
     // assert arr.length == 4
     frame_dig 0
     dup
@@ -1021,7 +1123,7 @@ test_uint64_array_after_for@4:
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:95
+    // tests/artifacts/Arrays/immutable.py:114
     // assert arr[-1] == 2
     intc_1 // 1
     -
@@ -1034,11 +1136,11 @@ test_uint64_array_after_for@4:
     intc_2 // 2
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:97
+    // tests/artifacts/Arrays/immutable.py:116
     // arr = add_x(arr, UInt64(10))
     pushint 10 // 10
     callsub add_x
-    // tests/artifacts/Arrays/immutable.py:98
+    // tests/artifacts/Arrays/immutable.py:117
     // assert arr.length == 14
     dup
     intc_0 // 0
@@ -1047,35 +1149,34 @@ test_uint64_array_after_for@4:
     pushint 14 // 14
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:99
+    // tests/artifacts/Arrays/immutable.py:118
     // assert arr[-1] == 9
+    dup
     intc_1 // 1
     -
-    swap
+    dig 2
     extract 2 0
     swap
     intc_3 // 8
     *
-    dig 1
-    swap
     extract_uint64
     pushint 9 // 9
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:101
+    // tests/artifacts/Arrays/immutable.py:120
     // arr = arr.append(UInt64(44))
     pushint 44 // 44
     itob
-    concat
-    dup
-    len
-    intc_3 // 8
-    /
+    uncover 2
+    swap
+    concat // on error: max array length exceeded
+    swap
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
-    // tests/artifacts/Arrays/immutable.py:102
+    replace2 0
+    // tests/artifacts/Arrays/immutable.py:121
     // assert arr.length == 15
     dup
     intc_0 // 0
@@ -1084,12 +1185,11 @@ test_uint64_array_after_for@4:
     pushint 15 // 15
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:103
+    // tests/artifacts/Arrays/immutable.py:122
     // assert arr[-1] == 44
-    dup
     intc_1 // 1
     -
-    dig 2
+    dig 1
     extract 2 0
     swap
     intc_3 // 8
@@ -1098,16 +1198,12 @@ test_uint64_array_after_for@4:
     pushint 44 // 44
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:105
+    // tests/artifacts/Arrays/immutable.py:124
     // arr = arr.replace(2, UInt64(23))
     pushint 23 // 23
     itob
-    intc_2 // 2
-    uncover 2
-    <
-    assert // Index access is out of bounds
     replace2 18
-    // tests/artifacts/Arrays/immutable.py:106
+    // tests/artifacts/Arrays/immutable.py:125
     // assert arr.length == 15
     dup
     intc_0 // 0
@@ -1115,7 +1211,7 @@ test_uint64_array_after_for@4:
     pushint 15 // 15
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:107
+    // tests/artifacts/Arrays/immutable.py:126
     // assert arr[2] == 23
     dup
     pushint 18 // 18
@@ -1123,7 +1219,7 @@ test_uint64_array_after_for@4:
     pushint 23 // 23
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:109
+    // tests/artifacts/Arrays/immutable.py:128
     // self.a = arr
     pushbytes "a"
     swap
@@ -1131,35 +1227,258 @@ test_uint64_array_after_for@4:
     retsub
 
 
-// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array(length: uint64) -> void:
-test_bool_array:
-    // tests/artifacts/Arrays/immutable.py:111-112
+// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_biguint_array() -> void:
+test_biguint_array:
+    // tests/artifacts/Arrays/immutable.py:130-131
     // @arc4.abimethod()
-    // def test_bool_array(self, length: UInt64) -> None:
-    proto 1 0
-    bytec_2 // ""
-    // tests/artifacts/Arrays/immutable.py:113
-    // arr = ImmutableArray[bool]()
-    bytec_3 // 0x0000
-    // tests/artifacts/Arrays/immutable.py:116
-    // for i in urange(length):
-    intc_0 // 0
-
-test_bool_array_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:116
-    // for i in urange(length):
-    frame_dig 2
-    frame_dig -1
-    <
-    bz test_bool_array_after_for@4
-    // tests/artifacts/Arrays/immutable.py:117
+    // def test_biguint_array(self) -> None:
+    proto 0 0
+    // tests/artifacts/Arrays/immutable.py:135
+    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
+    txn NumAppArgs
+    intc_1 // 1
+    -
+    itob
+    pushint 64 // 64
+    bzero
+    dup
+    cover 2
+    b|
+    // tests/artifacts/Arrays/immutable.py:132
+    // arr = ImmutableArray[BigUInt]()
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:135
+    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
+    swap
+    concat // on error: max array length exceeded
+    pushbytes 0x0001
+    replace2 0
+    dupn 2
+    // tests/artifacts/Arrays/immutable.py:136
+    // assert arr.length == 1
+    intc_0 // 0
+    extract_uint16
+    dup
+    intc_1 // 1
+    ==
+    assert
+    // tests/artifacts/Arrays/immutable.py:137
+    // assert arr[-1] == 0
+    intc_1 // 1
+    -
+    swap
+    extract 2 0
+    swap
+    pushint 64 // 64
+    *
+    pushint 64 // 64
+    extract3 // on error: index access is out of bounds
+    bytec_1 // 0x
+    b==
+    assert
+    // tests/artifacts/Arrays/immutable.py:512
+    // for i in urange(x):
+    intc_0 // 0
+
+test_biguint_array_for_header@2:
+    // tests/artifacts/Arrays/immutable.py:512
+    // for i in urange(x):
+    frame_dig 2
+    // tests/artifacts/Arrays/immutable.py:139
+    // arr = add_xb(arr, UInt64(5))
+    pushint 5 // 5
+    // tests/artifacts/Arrays/immutable.py:512
+    // for i in urange(x):
+    <
+    bz test_biguint_array_after_for@4
+    // tests/artifacts/Arrays/immutable.py:513
+    // arr = arr.append(BigUInt(i))
+    frame_dig 2
+    dup
+    itob
+    frame_dig 0
+    b|
+    frame_dig 1
+    dup
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
+    itob
+    extract 6 2
+    replace2 0
+    frame_bury 1
+    // tests/artifacts/Arrays/immutable.py:512
+    // for i in urange(x):
+    intc_1 // 1
+    +
+    frame_bury 2
+    b test_biguint_array_for_header@2
+
+test_biguint_array_after_for@4:
+    // tests/artifacts/Arrays/immutable.py:140
+    // assert arr.length == 6
+    frame_dig 1
+    dup
+    intc_0 // 0
+    extract_uint16
+    dup
+    pushint 6 // 6
+    ==
+    assert
+    // tests/artifacts/Arrays/immutable.py:141
+    // assert arr[-1] == 4
+    dup
+    intc_1 // 1
+    -
+    dig 2
+    extract 2 0
+    swap
+    pushint 64 // 64
+    *
+    pushint 64 // 64
+    extract3 // on error: index access is out of bounds
+    pushbytes 0x04
+    b==
+    assert
+    // tests/artifacts/Arrays/immutable.py:143
+    // arr = arr.append(BigUInt(2**512 - 1) - Txn.num_app_args)
+    txn NumAppArgs
+    itob
+    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+    swap
+    b-
+    dup
+    len
+    pushint 64 // 64
+    <=
+    assert // overflow
+    frame_dig 0
+    b|
+    uncover 2
+    swap
+    concat // on error: max array length exceeded
+    swap
+    intc_1 // 1
+    +
+    itob
+    extract 6 2
+    replace2 0
+    // tests/artifacts/Arrays/immutable.py:144
+    // assert arr.length == 7
+    dup
+    intc_0 // 0
+    extract_uint16
+    dup
+    pushint 7 // 7
+    ==
+    assert
+    // tests/artifacts/Arrays/immutable.py:145
+    // assert arr[-1] == 2**512 - 2
+    dup
+    intc_1 // 1
+    -
+    dig 2
+    extract 2 0
+    swap
+    pushint 64 // 64
+    *
+    pushint 64 // 64
+    extract3 // on error: index access is out of bounds
+    pushbytes 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
+    b==
+    assert
+    // tests/artifacts/Arrays/immutable.py:146
+    // assert arr[0] == 0
+    dig 1
+    extract 2 64
+    bytec_1 // 0x
+    b==
+    assert
+    // tests/artifacts/Arrays/immutable.py:148
+    // arr = arr.append(BigUInt(2**512 - 1))
+    swap
+    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+    concat // on error: max array length exceeded
+    swap
+    intc_1 // 1
+    +
+    itob
+    extract 6 2
+    replace2 0
+    // tests/artifacts/Arrays/immutable.py:149
+    // assert arr.length == 8
+    dup
+    intc_0 // 0
+    extract_uint16
+    dup
+    intc_3 // 8
+    ==
+    assert
+    // tests/artifacts/Arrays/immutable.py:150
+    // assert arr[-1] == 2**512 - 1
+    intc_1 // 1
+    -
+    dig 1
+    extract 2 0
+    swap
+    pushint 64 // 64
+    *
+    pushint 64 // 64
+    extract3 // on error: index access is out of bounds
+    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+    b==
+    assert
+    // tests/artifacts/Arrays/immutable.py:151
+    // assert arr[0] == 0
+    dup
+    extract 2 64
+    bytec_1 // 0x
+    b==
+    assert
+    // tests/artifacts/Arrays/immutable.py:153
+    // Box(ImmutableArray[BigUInt], key=b"biguint").value = arr
+    bytec 7 // 0x62696775696e74
+    box_del
+    pop
+    bytec 7 // 0x62696775696e74
+    swap
+    box_put
+    retsub
+
+
+// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array(length: uint64) -> void:
+test_bool_array:
+    // tests/artifacts/Arrays/immutable.py:155-156
+    // @arc4.abimethod()
+    // def test_bool_array(self, length: UInt64) -> None:
+    proto 1 0
+    bytec_1 // ""
+    // tests/artifacts/Arrays/immutable.py:157
+    // arr = ImmutableArray[bool]()
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:160
+    // for i in urange(length):
+    intc_0 // 0
+
+test_bool_array_for_header@1:
+    // tests/artifacts/Arrays/immutable.py:160
+    // for i in urange(length):
+    frame_dig 2
+    frame_dig -1
+    <
+    bz test_bool_array_after_for@4
+    // tests/artifacts/Arrays/immutable.py:161
     // arr = arr.append(i == Txn.num_app_args)
     txn NumAppArgs
     frame_dig 2
     dup
     uncover 2
     ==
-    bytec_0 // 0x00
+    bytec_3 // 0x00
     intc_0 // 0
     uncover 2
     setbit
@@ -1169,7 +1488,7 @@ test_bool_array_for_header@1:
     intc_3 // 8
     callsub dynamic_array_concat_bits
     frame_bury 1
-    // tests/artifacts/Arrays/immutable.py:116
+    // tests/artifacts/Arrays/immutable.py:160
     // for i in urange(length):
     intc_1 // 1
     +
@@ -1177,7 +1496,7 @@ test_bool_array_for_header@1:
     b test_bool_array_for_header@1
 
 test_bool_array_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:119
+    // tests/artifacts/Arrays/immutable.py:163
     // assert arr.length == length
     frame_dig 1
     intc_0 // 0
@@ -1187,114 +1506,88 @@ test_bool_array_after_for@4:
     frame_dig -1
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:121
+    // tests/artifacts/Arrays/immutable.py:165
     // if length > 0:
     frame_dig -1
     bz test_bool_array_after_if_else@6
-    // tests/artifacts/Arrays/immutable.py:122
+    // tests/artifacts/Arrays/immutable.py:166
     // assert not arr[0], "expected element 0 to be False"
-    frame_dig 1
-    extract 2 0
     frame_dig 0
-    assert // Index access is out of bounds
-    intc_0 // 0
-    getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
+    assert // index access is out of bounds
+    frame_dig 1
+    pushint 16 // 16
     getbit
     !
     assert // expected element 0 to be False
 
 test_bool_array_after_if_else@6:
-    // tests/artifacts/Arrays/immutable.py:123
+    // tests/artifacts/Arrays/immutable.py:167
     // if length > 1:
     frame_dig -1
     intc_1 // 1
     >
     bz test_bool_array_after_if_else@8
-    // tests/artifacts/Arrays/immutable.py:124
+    // tests/artifacts/Arrays/immutable.py:168
     // assert not arr[1], "expected element 1 to be False"
-    frame_dig 1
-    extract 2 0
     intc_1 // 1
     frame_dig 0
     <
-    assert // Index access is out of bounds
-    intc_1 // 1
-    getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
+    assert // index access is out of bounds
+    frame_dig 1
+    pushint 17 // 17
     getbit
     !
     assert // expected element 1 to be False
 
 test_bool_array_after_if_else@8:
-    // tests/artifacts/Arrays/immutable.py:125
+    // tests/artifacts/Arrays/immutable.py:169
     // if length > 2:
     frame_dig -1
     intc_2 // 2
     >
     bz test_bool_array_after_if_else@10
-    // tests/artifacts/Arrays/immutable.py:126
+    // tests/artifacts/Arrays/immutable.py:170
     // assert arr[2], "expected element 2 to be True"
-    frame_dig 1
-    extract 2 0
     intc_2 // 2
     frame_dig 0
     <
-    assert // Index access is out of bounds
-    intc_2 // 2
-    getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
+    assert // index access is out of bounds
+    frame_dig 1
+    pushint 18 // 18
     getbit
     assert // expected element 2 to be True
 
 test_bool_array_after_if_else@10:
-    // tests/artifacts/Arrays/immutable.py:127
+    // tests/artifacts/Arrays/immutable.py:171
     // if length > 3:
     frame_dig -1
     pushint 3 // 3
     >
     bz test_bool_array_after_if_else@12
-    // tests/artifacts/Arrays/immutable.py:128
+    // tests/artifacts/Arrays/immutable.py:172
     // assert not arr[length - 1], "expected last element to be False"
     frame_dig -1
     intc_1 // 1
     -
-    frame_dig 1
-    extract 2 0
-    dig 1
+    dup
     frame_dig 0
     <
-    assert // Index access is out of bounds
+    assert // index access is out of bounds
+    pushint 16 // 16
+    +
+    frame_dig 1
     swap
     getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
-    getbit
     !
     assert // expected last element to be False
 
 test_bool_array_after_if_else@12:
-    // tests/artifacts/Arrays/immutable.py:130
+    // tests/artifacts/Arrays/immutable.py:174
     // self.g = arr
     pushbytes "g"
     frame_dig 1
     app_global_put
-    // tests/artifacts/Arrays/immutable.py:131
+    // tests/artifacts/Arrays/immutable.py:175
     // if length:
     frame_dig -1
     bz test_bool_array_after_if_else@14
@@ -1322,7 +1615,7 @@ test_bool_array_after_if_else@12:
     intc_0 // 0
     swap
     substring3
-    // tests/artifacts/Arrays/immutable.py:133
+    // tests/artifacts/Arrays/immutable.py:177
     // assert arr.length == length - 1
     intc_0 // 0
     extract_uint16
@@ -1338,28 +1631,26 @@ test_bool_array_after_if_else@14:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_tuple_array() -> void:
 test_fixed_size_tuple_array:
-    // tests/artifacts/Arrays/immutable.py:135-136
+    // tests/artifacts/Arrays/immutable.py:179-180
     // @arc4.abimethod()
     // def test_fixed_size_tuple_array(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/immutable.py:137
+    // tests/artifacts/Arrays/immutable.py:181
     // arr = ImmutableArray[tuple[UInt64, UInt64]]()
-    bytec_3 // 0x0000
-    // tests/artifacts/Arrays/immutable.py:140
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:184
     // for i in urange(5):
     intc_0 // 0
 
 test_fixed_size_tuple_array_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:140
+    // tests/artifacts/Arrays/immutable.py:184
     // for i in urange(5):
     frame_dig 1
     pushint 5 // 5
     <
     bz test_fixed_size_tuple_array_after_for@4
-    // tests/artifacts/Arrays/immutable.py:141
+    // tests/artifacts/Arrays/immutable.py:185
     // arr = arr.append((i + 1, i + 2))
-    frame_dig 0
-    extract 2 0
     frame_dig 1
     dup
     intc_1 // 1
@@ -1372,23 +1663,24 @@ test_fixed_size_tuple_array_for_header@1:
     swap
     itob
     concat
+    frame_dig 0
+    dup
     uncover 2
+    concat // on error: max array length exceeded
     swap
-    concat
-    dup
-    len
-    pushint 16 // 16
-    /
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 0
     frame_bury 1
     b test_fixed_size_tuple_array_for_header@1
 
 test_fixed_size_tuple_array_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:143
+    // tests/artifacts/Arrays/immutable.py:187
     // assert arr.length == 5
     frame_dig 0
     dup
@@ -1398,7 +1690,7 @@ test_fixed_size_tuple_array_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:144
+    // tests/artifacts/Arrays/immutable.py:188
     // assert arr[0] == (UInt64(1), UInt64(2))
     dig 1
     extract 2 0
@@ -1418,7 +1710,7 @@ test_fixed_size_tuple_array_after_for@4:
     ==
     &&
     assert
-    // tests/artifacts/Arrays/immutable.py:145
+    // tests/artifacts/Arrays/immutable.py:189
     // assert arr[-1] == (UInt64(5), UInt64(6))
     swap
     intc_1 // 1
@@ -1426,7 +1718,7 @@ test_fixed_size_tuple_array_after_for@4:
     pushint 16 // 16
     *
     pushint 16 // 16
-    extract3 // on error: Index access is out of bounds
+    extract3 // on error: index access is out of bounds
     dup
     intc_0 // 0
     extract_uint64
@@ -1441,12 +1733,12 @@ test_fixed_size_tuple_array_after_for@4:
     ==
     &&
     assert
-    // tests/artifacts/Arrays/immutable.py:147
+    // tests/artifacts/Arrays/immutable.py:191
     // arr = arr.pop()
     pushint 16 // 16
     callsub dynamic_array_pop_fixed_size
     bury 1
-    // tests/artifacts/Arrays/immutable.py:148
+    // tests/artifacts/Arrays/immutable.py:192
     // assert arr.length == 4
     dup
     intc_0 // 0
@@ -1455,7 +1747,7 @@ test_fixed_size_tuple_array_after_for@4:
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:149
+    // tests/artifacts/Arrays/immutable.py:193
     // assert arr[0] == (UInt64(1), UInt64(2))
     dig 1
     extract 2 0
@@ -1475,7 +1767,7 @@ test_fixed_size_tuple_array_after_for@4:
     ==
     &&
     assert
-    // tests/artifacts/Arrays/immutable.py:150
+    // tests/artifacts/Arrays/immutable.py:194
     // assert arr[-1] == (UInt64(4), UInt64(5))
     swap
     intc_1 // 1
@@ -1483,7 +1775,7 @@ test_fixed_size_tuple_array_after_for@4:
     pushint 16 // 16
     *
     pushint 16 // 16
-    extract3 // on error: Index access is out of bounds
+    extract3 // on error: index access is out of bounds
     dup
     intc_0 // 0
     extract_uint64
@@ -1498,7 +1790,7 @@ test_fixed_size_tuple_array_after_for@4:
     ==
     &&
     assert
-    // tests/artifacts/Arrays/immutable.py:151
+    // tests/artifacts/Arrays/immutable.py:195
     // self.c = arr
     pushbytes "c"
     swap
@@ -1508,28 +1800,26 @@ test_fixed_size_tuple_array_after_for@4:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_named_tuple_array() -> void:
 test_fixed_size_named_tuple_array:
-    // tests/artifacts/Arrays/immutable.py:153-154
+    // tests/artifacts/Arrays/immutable.py:197-198
     // @arc4.abimethod()
     // def test_fixed_size_named_tuple_array(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/immutable.py:155
+    // tests/artifacts/Arrays/immutable.py:199
     // arr = ImmutableArray[MyTuple]()
-    bytec_3 // 0x0000
-    // tests/artifacts/Arrays/immutable.py:158
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:202
     // for i in urange(5):
     intc_0 // 0
 
 test_fixed_size_named_tuple_array_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:158
+    // tests/artifacts/Arrays/immutable.py:202
     // for i in urange(5):
     frame_dig 1
     pushint 5 // 5
     <
     bz test_fixed_size_named_tuple_array_after_for@4
-    // tests/artifacts/Arrays/immutable.py:159
+    // tests/artifacts/Arrays/immutable.py:203
     // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
-    frame_dig 0
-    extract 2 0
     frame_dig 1
     dup
     intc_2 // 2
@@ -1543,27 +1833,28 @@ test_fixed_size_named_tuple_array_for_header@1:
     !
     dig 2
     itob
-    bytec_0 // 0x00
-    bytec 5 // 0x80
+    bytec_3 // 0x00
+    intc_0 // 0
     uncover 4
-    select
-    concat
-    pushint 65 // 65
-    uncover 2
     setbit
-    uncover 2
-    swap
+    intc_1 // 1
+    uncover 3
+    setbit
     concat
+    frame_dig 0
     dup
-    len
-    pushint 9 // 9
-    /
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:158
+    // tests/artifacts/Arrays/immutable.py:202
     // for i in urange(5):
     intc_1 // 1
     +
@@ -1571,7 +1862,7 @@ test_fixed_size_named_tuple_array_for_header@1:
     b test_fixed_size_named_tuple_array_for_header@1
 
 test_fixed_size_named_tuple_array_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:161
+    // tests/artifacts/Arrays/immutable.py:205
     // assert arr.length == 5
     frame_dig 0
     dup
@@ -1580,7 +1871,7 @@ test_fixed_size_named_tuple_array_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:162
+    // tests/artifacts/Arrays/immutable.py:206
     // foo, bar, baz = arr[0]
     dup
     extract 2 9
@@ -1590,34 +1881,22 @@ test_fixed_size_named_tuple_array_after_for@4:
     dig 1
     pushint 64 // 64
     getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
-    getbit
     uncover 2
     pushint 65 // 65
     getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
-    getbit
-    // tests/artifacts/Arrays/immutable.py:163
+    // tests/artifacts/Arrays/immutable.py:207
     // assert foo == 0
     uncover 2
     !
     assert
-    // tests/artifacts/Arrays/immutable.py:164
+    // tests/artifacts/Arrays/immutable.py:208
     // assert bar
     swap
     assert
-    // tests/artifacts/Arrays/immutable.py:165
+    // tests/artifacts/Arrays/immutable.py:209
     // assert baz
     assert
-    // tests/artifacts/Arrays/immutable.py:166
+    // tests/artifacts/Arrays/immutable.py:210
     // self.d = arr
     pushbytes "d"
     swap
@@ -1627,26 +1906,26 @@ test_fixed_size_named_tuple_array_after_for@4:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_tuple_array() -> void:
 test_dynamic_sized_tuple_array:
-    // tests/artifacts/Arrays/immutable.py:168-169
+    // tests/artifacts/Arrays/immutable.py:212-213
     // @arc4.abimethod()
     // def test_dynamic_sized_tuple_array(self) -> None:
     proto 0 0
-    bytec_2 // ""
-    // tests/artifacts/Arrays/immutable.py:170
+    bytec_1 // ""
+    // tests/artifacts/Arrays/immutable.py:214
     // arr = ImmutableArray[tuple[UInt64, Bytes]]()
-    bytec_3 // 0x0000
-    // tests/artifacts/Arrays/immutable.py:173
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:217
     // for i in urange(5):
     intc_0 // 0
 
 test_dynamic_sized_tuple_array_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:173
+    // tests/artifacts/Arrays/immutable.py:217
     // for i in urange(5):
     frame_dig 2
     pushint 5 // 5
     <
     bz test_dynamic_sized_tuple_array_after_for@4
-    // tests/artifacts/Arrays/immutable.py:174
+    // tests/artifacts/Arrays/immutable.py:218
     // arr = arr.append((i + 1, op.bzero(i)))
     frame_dig 2
     dup
@@ -1654,13 +1933,19 @@ test_dynamic_sized_tuple_array_for_header@1:
     +
     swap
     bzero
-    dig 1
+    frame_dig 1
+    dup
+    intc_0 // 0
+    extract_uint16
+    swap
+    extract 2 0
+    dig 3
     itob
-    dig 1
+    dig 3
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 4
     concat
     swap
     bytec 6 // 0x000a
@@ -1670,12 +1955,7 @@ test_dynamic_sized_tuple_array_for_header@1:
     bytec 4 // 0x0002
     swap
     concat
-    frame_dig 1
-    dup
-    intc_0 // 0
-    extract_uint16
-    swap
-    extract 2 0
+    cover 2
     intc_1 // 1
     uncover 3
     callsub dynamic_array_concat_dynamic_element
@@ -1684,7 +1964,7 @@ test_dynamic_sized_tuple_array_for_header@1:
     b test_dynamic_sized_tuple_array_for_header@1
 
 test_dynamic_sized_tuple_array_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:176
+    // tests/artifacts/Arrays/immutable.py:220
     // assert arr.length == 5
     frame_dig 1
     intc_0 // 0
@@ -1694,19 +1974,19 @@ test_dynamic_sized_tuple_array_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:177
+    // tests/artifacts/Arrays/immutable.py:221
     // for i in urange(5):
     intc_0 // 0
     frame_bury 2
 
 test_dynamic_sized_tuple_array_for_header@5:
-    // tests/artifacts/Arrays/immutable.py:177
+    // tests/artifacts/Arrays/immutable.py:221
     // for i in urange(5):
     frame_dig 2
     pushint 5 // 5
     <
     bz test_dynamic_sized_tuple_array_after_for@8
-    // tests/artifacts/Arrays/immutable.py:178
+    // tests/artifacts/Arrays/immutable.py:222
     // assert arr[i][0] == i + 1, "expected 1st element to be correct"
     frame_dig 1
     extract 2 0
@@ -1723,7 +2003,7 @@ test_dynamic_sized_tuple_array_for_header@5:
     +
     frame_dig 0
     dig 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     dig 3
     len
     dig 2
@@ -1749,13 +2029,13 @@ test_dynamic_sized_tuple_array_for_header@5:
     uncover 3
     cover 2
     substring3
+    extract 2 0
     swap
     dig 2
     ==
     assert // expected 1st element to be correct
-    // tests/artifacts/Arrays/immutable.py:179
+    // tests/artifacts/Arrays/immutable.py:223
     // assert arr[i][1].length == i, "expected 2nd element to be correct"
-    extract 2 0
     len
     uncover 2
     ==
@@ -1764,12 +2044,12 @@ test_dynamic_sized_tuple_array_for_header@5:
     b test_dynamic_sized_tuple_array_for_header@5
 
 test_dynamic_sized_tuple_array_after_for@8:
-    // tests/artifacts/Arrays/immutable.py:181
+    // tests/artifacts/Arrays/immutable.py:225
     // arr = arr.pop()
     frame_dig 1
     callsub dynamic_array_pop_dynamic_element
     bury 1
-    // tests/artifacts/Arrays/immutable.py:182
+    // tests/artifacts/Arrays/immutable.py:226
     // assert arr.length == 4
     dup
     intc_0 // 0
@@ -1778,7 +2058,7 @@ test_dynamic_sized_tuple_array_after_for@8:
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:183
+    // tests/artifacts/Arrays/immutable.py:227
     // assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
     dig 1
     extract 2 0
@@ -1787,7 +2067,7 @@ test_dynamic_sized_tuple_array_after_for@8:
     extract_uint16
     dig 2
     intc_1 // 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     dig 2
     len
     dig 3
@@ -1822,7 +2102,7 @@ test_dynamic_sized_tuple_array_after_for@8:
     ==
     &&
     assert // expected 1, 0
-    // tests/artifacts/Arrays/immutable.py:184
+    // tests/artifacts/Arrays/immutable.py:228
     // assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
     dig 1
     intc_2 // 2
@@ -1835,7 +2115,7 @@ test_dynamic_sized_tuple_array_after_for@8:
     +
     uncover 4
     dig 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     swap
     intc_2 // 2
     *
@@ -1868,7 +2148,7 @@ test_dynamic_sized_tuple_array_after_for@8:
     ==
     &&
     assert // expected 4, 3
-    // tests/artifacts/Arrays/immutable.py:185
+    // tests/artifacts/Arrays/immutable.py:229
     // self.e = arr
     pushbytes "e"
     swap
@@ -1878,26 +2158,26 @@ test_dynamic_sized_tuple_array_after_for@8:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_named_tuple_array() -> void:
 test_dynamic_sized_named_tuple_array:
-    // tests/artifacts/Arrays/immutable.py:187-188
+    // tests/artifacts/Arrays/immutable.py:231-232
     // @arc4.abimethod()
     // def test_dynamic_sized_named_tuple_array(self) -> None:
     proto 0 0
-    bytec_2 // ""
-    // tests/artifacts/Arrays/immutable.py:189
+    bytec_1 // ""
+    // tests/artifacts/Arrays/immutable.py:233
     // arr = ImmutableArray[MyDynamicSizedTuple]()
-    bytec_3 // 0x0000
-    // tests/artifacts/Arrays/immutable.py:192
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:236
     // for i in urange(5):
     intc_0 // 0
 
 test_dynamic_sized_named_tuple_array_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:192
+    // tests/artifacts/Arrays/immutable.py:236
     // for i in urange(5):
     frame_dig 2
     pushint 5 // 5
     <
     bz test_dynamic_sized_named_tuple_array_after_for@4
-    // tests/artifacts/Arrays/immutable.py:193
+    // tests/artifacts/Arrays/immutable.py:237
     // arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
     frame_dig 2
     dup
@@ -1905,13 +2185,19 @@ test_dynamic_sized_named_tuple_array_for_header@1:
     +
     swap
     callsub times
-    dig 1
+    frame_dig 1
+    dup
+    intc_0 // 0
+    extract_uint16
+    swap
+    extract 2 0
+    dig 3
     itob
-    dig 1
+    dig 3
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 4
     concat
     swap
     bytec 6 // 0x000a
@@ -1921,12 +2207,7 @@ test_dynamic_sized_named_tuple_array_for_header@1:
     bytec 4 // 0x0002
     swap
     concat
-    frame_dig 1
-    dup
-    intc_0 // 0
-    extract_uint16
-    swap
-    extract 2 0
+    cover 2
     intc_1 // 1
     uncover 3
     callsub dynamic_array_concat_dynamic_element
@@ -1935,7 +2216,7 @@ test_dynamic_sized_named_tuple_array_for_header@1:
     b test_dynamic_sized_named_tuple_array_for_header@1
 
 test_dynamic_sized_named_tuple_array_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:195
+    // tests/artifacts/Arrays/immutable.py:239
     // assert arr.length == 5
     frame_dig 1
     intc_0 // 0
@@ -1945,19 +2226,19 @@ test_dynamic_sized_named_tuple_array_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:196
+    // tests/artifacts/Arrays/immutable.py:240
     // for i in urange(5):
     intc_0 // 0
     frame_bury 2
 
 test_dynamic_sized_named_tuple_array_for_header@5:
-    // tests/artifacts/Arrays/immutable.py:196
+    // tests/artifacts/Arrays/immutable.py:240
     // for i in urange(5):
     frame_dig 2
     pushint 5 // 5
     <
     bz test_dynamic_sized_named_tuple_array_after_for@8
-    // tests/artifacts/Arrays/immutable.py:197
+    // tests/artifacts/Arrays/immutable.py:241
     // assert arr[i][0] == i + 1, "expected 1st element to be correct"
     frame_dig 1
     extract 2 0
@@ -1974,7 +2255,7 @@ test_dynamic_sized_named_tuple_array_for_header@5:
     +
     frame_dig 0
     dig 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     dig 3
     len
     dig 2
@@ -2000,13 +2281,13 @@ test_dynamic_sized_named_tuple_array_for_header@5:
     uncover 3
     cover 2
     substring3
+    extract 2 0
     swap
     dig 2
     ==
     assert // expected 1st element to be correct
-    // tests/artifacts/Arrays/immutable.py:198
+    // tests/artifacts/Arrays/immutable.py:242
     // assert arr[i][1] == times(i), "expected 2nd element to be correct"
-    extract 2 0
     uncover 2
     callsub times
     ==
@@ -2015,12 +2296,12 @@ test_dynamic_sized_named_tuple_array_for_header@5:
     b test_dynamic_sized_named_tuple_array_for_header@5
 
 test_dynamic_sized_named_tuple_array_after_for@8:
-    // tests/artifacts/Arrays/immutable.py:200
+    // tests/artifacts/Arrays/immutable.py:244
     // arr = arr.pop()
     frame_dig 1
     callsub dynamic_array_pop_dynamic_element
     bury 1
-    // tests/artifacts/Arrays/immutable.py:201
+    // tests/artifacts/Arrays/immutable.py:245
     // assert arr.length == 4
     dup
     intc_0 // 0
@@ -2029,7 +2310,7 @@ test_dynamic_sized_named_tuple_array_after_for@8:
     pushint 4 // 4
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:202
+    // tests/artifacts/Arrays/immutable.py:246
     // assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
     dig 1
     extract 2 0
@@ -2038,7 +2319,7 @@ test_dynamic_sized_named_tuple_array_after_for@8:
     extract_uint16
     dig 2
     intc_1 // 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     dig 2
     len
     dig 3
@@ -2068,11 +2349,11 @@ test_dynamic_sized_named_tuple_array_after_for@8:
     intc_1 // 1
     ==
     swap
-    bytec_2 // ""
+    bytec_1 // ""
     ==
     &&
     assert // expected 1, 0
-    // tests/artifacts/Arrays/immutable.py:203
+    // tests/artifacts/Arrays/immutable.py:247
     // assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
     dig 1
     intc_2 // 2
@@ -2085,7 +2366,7 @@ test_dynamic_sized_named_tuple_array_after_for@8:
     +
     uncover 4
     dig 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     swap
     intc_2 // 2
     *
@@ -2117,7 +2398,7 @@ test_dynamic_sized_named_tuple_array_after_for@8:
     ==
     &&
     assert // expected 4, 3
-    // tests/artifacts/Arrays/immutable.py:204
+    // tests/artifacts/Arrays/immutable.py:248
     // self.f = arr
     pushbytes "f"
     swap
@@ -2127,11 +2408,11 @@ test_dynamic_sized_named_tuple_array_after_for@8:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_log(arr: bytes) -> void:
 test_implicit_conversion_log:
-    // tests/artifacts/Arrays/immutable.py:206-207
+    // tests/artifacts/Arrays/immutable.py:250-251
     // @arc4.abimethod()
     // def test_implicit_conversion_log(self, arr: ImmutableArray[UInt64]) -> None:
     proto 1 0
-    // tests/artifacts/Arrays/immutable.py:208
+    // tests/artifacts/Arrays/immutable.py:252
     // log(arr)
     frame_dig -1
     log
@@ -2140,137 +2421,135 @@ test_implicit_conversion_log:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_emit(arr: bytes) -> void:
 test_implicit_conversion_emit:
-    // tests/artifacts/Arrays/immutable.py:210-211
+    // tests/artifacts/Arrays/immutable.py:254-255
     // @arc4.abimethod()
     // def test_implicit_conversion_emit(self, arr: ImmutableArray[UInt64]) -> None:
     proto 1 0
-    // tests/artifacts/Arrays/immutable.py:212
+    // tests/artifacts/Arrays/immutable.py:256
     // arc4.emit("emit_test", arr)
-    bytec 4 // 0x0002
+    pushbytes 0xfa40c0530002
     frame_dig -1
     concat
-    pushbytes 0xfa40c053 // method "emit_test(uint64[])"
-    swap
-    concat
     log
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_nested_array(arr_to_add: uint64, arr: bytes) -> bytes:
 test_nested_array:
-    // tests/artifacts/Arrays/immutable.py:214-217
+    // tests/artifacts/Arrays/immutable.py:258-261
     // @arc4.abimethod()
     // def test_nested_array(
     //     self, arr_to_add: UInt64, arr: ImmutableArray[ImmutableArray[UInt64]]
     // ) -> ImmutableArray[UInt64]:
     proto 2 1
     intc_0 // 0
-    dupn 3
-    bytec_2 // ""
+    dupn 2
+    bytec_1 // ""
     dupn 5
-    // tests/artifacts/Arrays/immutable.py:218-219
+    // tests/artifacts/Arrays/immutable.py:262-263
     // # add n new arrays
     // for i in urange(arr_to_add):
     intc_0 // 0
 
 test_nested_array_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:218-219
+    // tests/artifacts/Arrays/immutable.py:262-263
     // # add n new arrays
     // for i in urange(arr_to_add):
-    frame_dig 10
+    frame_dig 9
     frame_dig -2
     <
     bz test_nested_array_after_for@8
-    // tests/artifacts/Arrays/immutable.py:220
+    // tests/artifacts/Arrays/immutable.py:264
     // extra_arr = ImmutableArray[UInt64]()
-    bytec_3 // 0x0000
-    frame_bury 1
-    // tests/artifacts/Arrays/immutable.py:221
+    bytec_2 // 0x0000
+    frame_bury 0
+    // tests/artifacts/Arrays/immutable.py:265
     // for j in urange(i):
     intc_0 // 0
-    frame_bury 8
+    frame_bury 7
 
 test_nested_array_for_header@3:
-    // tests/artifacts/Arrays/immutable.py:221
+    // tests/artifacts/Arrays/immutable.py:265
     // for j in urange(i):
-    frame_dig 8
-    frame_dig 10
+    frame_dig 7
+    frame_dig 9
     <
     bz test_nested_array_after_for@6
-    // tests/artifacts/Arrays/immutable.py:222
+    // tests/artifacts/Arrays/immutable.py:266
     // extra_arr = extra_arr.append(j)
-    frame_dig 1
-    extract 2 0
-    frame_dig 8
+    frame_dig 7
     dup
-    cover 2
     itob
-    concat
+    frame_dig 0
     dup
-    len
-    intc_3 // 8
-    /
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
-    frame_bury 1
-    // tests/artifacts/Arrays/immutable.py:221
+    replace2 0
+    frame_bury 0
+    // tests/artifacts/Arrays/immutable.py:265
     // for j in urange(i):
     intc_1 // 1
     +
-    frame_bury 8
+    frame_bury 7
     b test_nested_array_for_header@3
 
 test_nested_array_after_for@6:
-    // tests/artifacts/Arrays/immutable.py:223
+    // tests/artifacts/Arrays/immutable.py:267
     // arr = arr.append(extra_arr)
-    bytec 4 // 0x0002
-    frame_dig 1
-    concat
     frame_dig -1
     intc_0 // 0
     extract_uint16
     frame_dig -1
     extract 2 0
+    bytec 4 // 0x0002
+    frame_dig 0
+    concat
+    cover 2
     intc_1 // 1
     uncover 3
     callsub dynamic_array_concat_dynamic_element
     frame_bury -1
-    // tests/artifacts/Arrays/immutable.py:218-219
+    // tests/artifacts/Arrays/immutable.py:262-263
     // # add n new arrays
     // for i in urange(arr_to_add):
-    frame_dig 10
+    frame_dig 9
     intc_1 // 1
     +
-    frame_bury 10
+    frame_bury 9
     b test_nested_array_for_header@1
 
 test_nested_array_after_for@8:
-    // tests/artifacts/Arrays/immutable.py:225-226
+    // tests/artifacts/Arrays/immutable.py:269-270
     // # sum inner arrays and return an array containing sums
     // totals = ImmutableArray[UInt64]()
-    bytec_3 // 0x0000
-    frame_bury 3
-    // tests/artifacts/Arrays/immutable.py:227
+    bytec_2 // 0x0000
+    frame_bury 2
+    // tests/artifacts/Arrays/immutable.py:271
     // for inner_arr in arr:
     frame_dig -1
     intc_0 // 0
     extract_uint16
-    frame_bury 4
+    frame_bury 3
     intc_0 // 0
-    frame_bury 6
+    frame_bury 5
 
 test_nested_array_for_header@9:
-    // tests/artifacts/Arrays/immutable.py:227
+    // tests/artifacts/Arrays/immutable.py:271
     // for inner_arr in arr:
-    frame_dig 6
-    frame_dig 4
+    frame_dig 5
+    frame_dig 3
     <
     bz test_nested_array_after_for@12
     frame_dig -1
     extract 2 0
-    frame_dig 6
+    frame_dig 5
     intc_2 // 2
     *
     dig 1
@@ -2284,210 +2563,161 @@ test_nested_array_for_header@9:
     +
     extract3
     dup
-    frame_bury 2
-    // tests/artifacts/Arrays/immutable.py:228
-    // totals = totals.append(sum_arr(inner_arr))
-    frame_dig 3
-    extract 2 0
-    frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:425
+    frame_bury 1
+    // tests/artifacts/Arrays/immutable.py:519
     // total = UInt64()
     intc_0 // 0
-    frame_bury 9
-    // tests/artifacts/Arrays/immutable.py:426
+    frame_bury 8
+    // tests/artifacts/Arrays/immutable.py:520
     // for i in arr:
     intc_0 // 0
     extract_uint16
-    frame_bury 5
+    frame_bury 4
     intc_0 // 0
-    frame_bury 7
+    frame_bury 6
 
 test_nested_array_for_header@14:
-    // tests/artifacts/Arrays/immutable.py:426
+    // tests/artifacts/Arrays/immutable.py:520
     // for i in arr:
-    frame_dig 7
-    frame_dig 5
+    frame_dig 6
+    frame_dig 4
     <
     bz test_nested_array_after_for@16
-    frame_dig 2
+    frame_dig 1
     extract 2 0
-    frame_dig 7
+    frame_dig 6
     dup
     cover 2
     intc_3 // 8
     *
     extract_uint64
-    // tests/artifacts/Arrays/immutable.py:427
+    // tests/artifacts/Arrays/immutable.py:521
     // total += i
-    frame_dig 9
+    frame_dig 8
     +
-    frame_bury 9
+    frame_bury 8
     intc_1 // 1
     +
-    frame_bury 7
+    frame_bury 6
     b test_nested_array_for_header@14
 
 test_nested_array_after_for@16:
-    // tests/artifacts/Arrays/immutable.py:428
-    // return total
-    frame_dig 9
-    itob
-    // tests/artifacts/Arrays/immutable.py:228
+    // tests/artifacts/Arrays/immutable.py:272
     // totals = totals.append(sum_arr(inner_arr))
-    frame_dig 0
-    swap
-    concat
-    dup
-    len
-    intc_3 // 8
-    /
+    frame_dig 8
     itob
-    extract 6 2
+    frame_dig 2
+    dup
+    uncover 2
+    concat // on error: max array length exceeded
     swap
-    concat
-    frame_bury 3
-    frame_dig 6
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
+    itob
+    extract 6 2
+    replace2 0
+    frame_bury 2
+    frame_dig 5
     intc_1 // 1
     +
-    frame_bury 6
+    frame_bury 5
     b test_nested_array_for_header@9
 
 test_nested_array_after_for@12:
-    // tests/artifacts/Arrays/immutable.py:230
+    // tests/artifacts/Arrays/immutable.py:274
     // return totals
-    frame_dig 3
+    frame_dig 2
     frame_bury 0
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bit_packed_tuples() -> void:
 test_bit_packed_tuples:
-    // tests/artifacts/Arrays/immutable.py:232-233
+    // tests/artifacts/Arrays/immutable.py:276-277
     // @arc4.abimethod()
     // def test_bit_packed_tuples(self) -> None:
     proto 0 0
-    // tests/artifacts/Arrays/immutable.py:234
+    // tests/artifacts/Arrays/immutable.py:278
     // arr2 = ImmutableArray[TwoBoolTuple]()
-    bytec_3 // 0x0000
-    // tests/artifacts/Arrays/immutable.py:235-237
+    bytec_2 // 0x0000
+    // tests/artifacts/Arrays/immutable.py:279-281
     // arr7 = ImmutableArray[SevenBoolTuple]()
     // arr8 = ImmutableArray[EightBoolTuple]()
     // arr9 = ImmutableArray[NineBoolTuple]()
     dupn 3
-    // tests/artifacts/Arrays/immutable.py:243
+    // tests/artifacts/Arrays/immutable.py:287
     // for i in urange(5):
     intc_0 // 0
 
 test_bit_packed_tuples_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:243
+    // tests/artifacts/Arrays/immutable.py:287
     // for i in urange(5):
     frame_dig 4
     pushint 5 // 5
     <
     bz test_bit_packed_tuples_after_for@4
-    // tests/artifacts/Arrays/immutable.py:244
+    // tests/artifacts/Arrays/immutable.py:288
     // arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
-    frame_dig 0
-    extract 2 0
     frame_dig 4
     dup
     !
     dig 1
     intc_1 // 1
     ==
-    bytec_0 // 0x00
-    bytec 5 // 0x80
+    bytec_3 // 0x00
+    intc_0 // 0
     uncover 3
-    select
-    dup
+    setbit
     intc_1 // 1
-    dig 3
+    uncover 2
     setbit
-    uncover 4
-    swap
-    concat
+    frame_dig 0
     dup
-    len
+    cover 2
+    dig 1
+    concat // on error: max array length exceeded
+    uncover 2
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:245-257
-    // arr7 = arr7.append(
-    //     SevenBoolTuple(
-    //         foo=i,
-    //         bar=i + 1,
-    //         a=i == 0,
-    //         b=i == 1,
-    //         c=i == 2,
-    //         d=i == 3,
-    //         e=i == 4,
-    //         f=i == 5,
-    //         g=i == 6,
-    //     )
-    // )
-    frame_dig 1
-    extract 2 0
-    // tests/artifacts/Arrays/immutable.py:251
+    // tests/artifacts/Arrays/immutable.py:295
     // c=i == 2,
-    dig 3
+    dig 1
     intc_2 // 2
     ==
-    // tests/artifacts/Arrays/immutable.py:252
+    // tests/artifacts/Arrays/immutable.py:296
     // d=i == 3,
-    dig 4
+    dig 2
     pushint 3 // 3
     ==
-    // tests/artifacts/Arrays/immutable.py:253
+    // tests/artifacts/Arrays/immutable.py:297
     // e=i == 4,
-    dig 5
+    dig 3
     pushint 4 // 4
     ==
-    // tests/artifacts/Arrays/immutable.py:254
+    // tests/artifacts/Arrays/immutable.py:298
     // f=i == 5,
-    dig 6
+    dig 4
     pushint 5 // 5
     ==
-    // tests/artifacts/Arrays/immutable.py:255
+    // tests/artifacts/Arrays/immutable.py:299
     // g=i == 6,
-    dig 7
+    dig 5
     pushint 6 // 6
     ==
-    // tests/artifacts/Arrays/immutable.py:248
+    // tests/artifacts/Arrays/immutable.py:292
     // bar=i + 1,
-    dig 8
+    dig 6
     intc_1 // 1
     +
-    // tests/artifacts/Arrays/immutable.py:247
-    // foo=i,
-    dig 9
-    itob
-    uncover 8
-    concat
-    pushint 65 // 65
-    uncover 9
-    setbit
-    pushint 66 // 66
-    uncover 7
-    setbit
-    pushint 67 // 67
-    uncover 6
-    setbit
-    pushint 68 // 68
-    uncover 5
-    setbit
-    pushint 69 // 69
-    uncover 4
-    setbit
-    pushint 70 // 70
-    uncover 3
-    setbit
-    dig 1
-    itob
-    dup2
-    concat
-    // tests/artifacts/Arrays/immutable.py:245-257
+    // tests/artifacts/Arrays/immutable.py:289-301
     // arr7 = arr7.append(
     //     SevenBoolTuple(
     //         foo=i,
@@ -2501,50 +2731,50 @@ test_bit_packed_tuples_for_header@1:
     //         g=i == 6,
     //     )
     // )
+    dig 7
+    itob
+    uncover 7
+    intc_2 // 2
+    uncover 8
+    setbit
+    pushint 3 // 3
+    uncover 7
+    setbit
+    pushint 4 // 4
+    uncover 6
+    setbit
+    pushint 5 // 5
+    uncover 5
+    setbit
+    pushint 6 // 6
     uncover 4
+    setbit
+    dup2
+    concat
+    dig 3
+    itob
     swap
+    dig 1
     concat
+    frame_dig 1
     dup
-    len
-    pushint 17 // 17
-    /
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 1
-    // tests/artifacts/Arrays/immutable.py:258-271
-    // arr8 = arr8.append(
-    //     EightBoolTuple(
-    //         foo=i,
-    //         bar=i + 1,
-    //         a=i == 0,
-    //         b=i == 1,
-    //         c=i == 2,
-    //         d=i == 3,
-    //         e=i == 4,
-    //         f=i == 5,
-    //         g=i == 6,
-    //         h=i == 7,
-    //     )
-    // )
-    frame_dig 2
-    extract 2 0
-    // tests/artifacts/Arrays/immutable.py:269
+    // tests/artifacts/Arrays/immutable.py:313
     // h=i == 7,
     dig 4
     pushint 7 // 7
     ==
-    // tests/artifacts/Arrays/immutable.py:260
-    // foo=i,
-    uncover 3
-    pushint 71 // 71
-    uncover 2
-    setbit
-    dup
-    dig 3
-    concat
-    // tests/artifacts/Arrays/immutable.py:258-271
+    // tests/artifacts/Arrays/immutable.py:302-315
     // arr8 = arr8.append(
     //     EightBoolTuple(
     //         foo=i,
@@ -2560,18 +2790,34 @@ test_bit_packed_tuples_for_header@1:
     //     )
     // )
     uncover 2
+    pushint 7 // 7
+    uncover 2
+    setbit
+    uncover 2
     swap
     concat
     dup
-    len
-    pushint 17 // 17
-    /
+    dig 2
+    concat
+    frame_dig 2
+    dup
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 2
-    // tests/artifacts/Arrays/immutable.py:272-286
+    // tests/artifacts/Arrays/immutable.py:328
+    // i=i == 8,
+    uncover 3
+    intc_3 // 8
+    ==
+    // tests/artifacts/Arrays/immutable.py:316-330
     // arr9 = arr9.append(
     //     NineBoolTuple(
     //         foo=i,
@@ -2587,55 +2833,31 @@ test_bit_packed_tuples_for_header@1:
     //         i=i == 8,
     //     )
     // )
-    frame_dig 3
-    extract 2 0
-    // tests/artifacts/Arrays/immutable.py:284
-    // i=i == 8,
-    uncover 4
-    intc_3 // 8
-    ==
-    // tests/artifacts/Arrays/immutable.py:274
-    // foo=i,
-    bytec_0 // 0x00
+    bytec_3 // 0x00
     intc_0 // 0
     uncover 2
     setbit
-    uncover 2
-    swap
-    concat
-    uncover 2
     concat
-    // tests/artifacts/Arrays/immutable.py:272-286
-    // arr9 = arr9.append(
-    //     NineBoolTuple(
-    //         foo=i,
-    //         bar=i + 1,
-    //         a=i == 0,
-    //         b=i == 1,
-    //         c=i == 2,
-    //         d=i == 3,
-    //         e=i == 4,
-    //         f=i == 5,
-    //         g=i == 6,
-    //         h=i == 7,
-    //         i=i == 8,
-    //     )
-    // )
+    swap
     concat
+    frame_dig 3
     dup
-    len
-    pushint 18 // 18
-    /
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 3
     frame_bury 4
     b test_bit_packed_tuples_for_header@1
 
 test_bit_packed_tuples_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:288
+    // tests/artifacts/Arrays/immutable.py:332
     // assert arr2.length == 5
     frame_dig 0
     dup
@@ -2644,7 +2866,7 @@ test_bit_packed_tuples_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:289
+    // tests/artifacts/Arrays/immutable.py:333
     // assert arr7.length == 5
     frame_dig 1
     dup
@@ -2653,7 +2875,7 @@ test_bit_packed_tuples_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:290
+    // tests/artifacts/Arrays/immutable.py:334
     // assert arr8.length == 5
     frame_dig 2
     dup
@@ -2662,7 +2884,7 @@ test_bit_packed_tuples_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:291
+    // tests/artifacts/Arrays/immutable.py:335
     // assert arr9.length == 5
     frame_dig 3
     dup
@@ -2671,22 +2893,22 @@ test_bit_packed_tuples_after_for@4:
     pushint 5 // 5
     ==
     assert
-    // tests/artifacts/Arrays/immutable.py:292
+    // tests/artifacts/Arrays/immutable.py:336
     // self.bool2 = arr2
     pushbytes "bool2"
     uncover 4
     app_global_put
-    // tests/artifacts/Arrays/immutable.py:293
+    // tests/artifacts/Arrays/immutable.py:337
     // self.bool7 = arr7
     pushbytes "bool7"
     uncover 3
     app_global_put
-    // tests/artifacts/Arrays/immutable.py:294
+    // tests/artifacts/Arrays/immutable.py:338
     // self.bool8 = arr8
     pushbytes "bool8"
     uncover 2
     app_global_put
-    // tests/artifacts/Arrays/immutable.py:295
+    // tests/artifacts/Arrays/immutable.py:339
     // self.bool9 = arr9
     pushbytes "bool9"
     swap
@@ -2696,7 +2918,7 @@ test_bit_packed_tuples_after_for@4:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.sum_uints_and_lengths_and_trues(arr1: bytes, arr2: bytes, arr3: bytes, arr4: bytes) -> uint64, uint64, uint64, uint64:
 sum_uints_and_lengths_and_trues:
-    // tests/artifacts/Arrays/immutable.py:297-304
+    // tests/artifacts/Arrays/immutable.py:341-348
     // @arc4.abimethod()
     // def sum_uints_and_lengths_and_trues(
     //     self,
@@ -2706,13 +2928,13 @@ sum_uints_and_lengths_and_trues:
     //     arr4: ImmutableArray[MyDynamicSizedTuple],
     // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
     proto 4 4
-    bytec_2 // ""
+    bytec_1 // ""
     dupn 8
-    // tests/artifacts/Arrays/immutable.py:305
+    // tests/artifacts/Arrays/immutable.py:349
     // sum1 = sum2 = sum3 = sum4 = UInt64()
     intc_0 // 0
     dupn 3
-    // tests/artifacts/Arrays/immutable.py:306
+    // tests/artifacts/Arrays/immutable.py:350
     // for i in arr1:
     frame_dig -4
     intc_0 // 0
@@ -2720,7 +2942,7 @@ sum_uints_and_lengths_and_trues:
     intc_0 // 0
 
 sum_uints_and_lengths_and_trues_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:306
+    // tests/artifacts/Arrays/immutable.py:350
     // for i in arr1:
     frame_dig 14
     frame_dig 13
@@ -2734,7 +2956,7 @@ sum_uints_and_lengths_and_trues_for_header@1:
     intc_3 // 8
     *
     extract_uint64
-    // tests/artifacts/Arrays/immutable.py:307
+    // tests/artifacts/Arrays/immutable.py:351
     // sum1 += i
     frame_dig 12
     +
@@ -2745,7 +2967,7 @@ sum_uints_and_lengths_and_trues_for_header@1:
     b sum_uints_and_lengths_and_trues_for_header@1
 
 sum_uints_and_lengths_and_trues_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:308
+    // tests/artifacts/Arrays/immutable.py:352
     // for b in arr2:
     frame_dig -3
     intc_0 // 0
@@ -2755,28 +2977,24 @@ sum_uints_and_lengths_and_trues_after_for@4:
     frame_bury 4
 
 sum_uints_and_lengths_and_trues_for_header@5:
-    // tests/artifacts/Arrays/immutable.py:308
+    // tests/artifacts/Arrays/immutable.py:352
     // for b in arr2:
     frame_dig 4
     frame_dig 0
     <
     bz sum_uints_and_lengths_and_trues_after_for@10
-    frame_dig -3
-    extract 2 0
     frame_dig 4
-    getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
+    pushint 16 // 16
+    +
+    frame_dig -3
+    swap
     getbit
     frame_dig 11
     frame_bury 6
-    // tests/artifacts/Arrays/immutable.py:309
+    // tests/artifacts/Arrays/immutable.py:353
     // if b:
     bz sum_uints_and_lengths_and_trues_after_if_else@8
-    // tests/artifacts/Arrays/immutable.py:310
+    // tests/artifacts/Arrays/immutable.py:354
     // sum2 += 1
     frame_dig 11
     intc_1 // 1
@@ -2793,7 +3011,7 @@ sum_uints_and_lengths_and_trues_after_if_else@8:
     b sum_uints_and_lengths_and_trues_for_header@5
 
 sum_uints_and_lengths_and_trues_after_for@10:
-    // tests/artifacts/Arrays/immutable.py:311
+    // tests/artifacts/Arrays/immutable.py:355
     // for tup in arr3:
     frame_dig -2
     intc_0 // 0
@@ -2803,7 +3021,7 @@ sum_uints_and_lengths_and_trues_after_for@10:
     frame_bury 5
 
 sum_uints_and_lengths_and_trues_for_header@11:
-    // tests/artifacts/Arrays/immutable.py:311
+    // tests/artifacts/Arrays/immutable.py:355
     // for tup in arr3:
     frame_dig 5
     frame_dig 1
@@ -2815,30 +3033,18 @@ sum_uints_and_lengths_and_trues_for_header@11:
     pushint 9 // 9
     *
     pushint 9 // 9
-    extract3 // on error: Index access is out of bounds
+    extract3 // on error: index access is out of bounds
     dup
     intc_0 // 0
     extract_uint64
     dig 1
     pushint 64 // 64
     getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
-    getbit
     uncover 2
     pushint 65 // 65
     getbit
-    bytec_0 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
-    getbit
     frame_bury 8
-    // tests/artifacts/Arrays/immutable.py:312
+    // tests/artifacts/Arrays/immutable.py:356
     // sum3 += tup.foo
     frame_dig 10
     uncover 2
@@ -2846,10 +3052,10 @@ sum_uints_and_lengths_and_trues_for_header@11:
     dup
     frame_bury 10
     frame_bury 7
-    // tests/artifacts/Arrays/immutable.py:313
+    // tests/artifacts/Arrays/immutable.py:357
     // if tup.bar:
     bz sum_uints_and_lengths_and_trues_after_if_else@14
-    // tests/artifacts/Arrays/immutable.py:314
+    // tests/artifacts/Arrays/immutable.py:358
     // sum3 += 1
     frame_dig 10
     intc_1 // 1
@@ -2861,11 +3067,11 @@ sum_uints_and_lengths_and_trues_after_if_else@14:
     dup
     frame_bury 10
     frame_bury 7
-    // tests/artifacts/Arrays/immutable.py:315
+    // tests/artifacts/Arrays/immutable.py:359
     // if tup.baz:
     frame_dig 8
     bz sum_uints_and_lengths_and_trues_after_if_else@16
-    // tests/artifacts/Arrays/immutable.py:316
+    // tests/artifacts/Arrays/immutable.py:360
     // sum3 += 1
     frame_dig 10
     intc_1 // 1
@@ -2882,7 +3088,7 @@ sum_uints_and_lengths_and_trues_after_if_else@16:
     b sum_uints_and_lengths_and_trues_for_header@11
 
 sum_uints_and_lengths_and_trues_after_for@18:
-    // tests/artifacts/Arrays/immutable.py:317
+    // tests/artifacts/Arrays/immutable.py:361
     // for idx, dyn_tup in uenumerate(arr4):
     frame_dig -1
     intc_0 // 0
@@ -2892,7 +3098,7 @@ sum_uints_and_lengths_and_trues_after_for@18:
     frame_bury 3
 
 sum_uints_and_lengths_and_trues_for_header@19:
-    // tests/artifacts/Arrays/immutable.py:317
+    // tests/artifacts/Arrays/immutable.py:361
     // for idx, dyn_tup in uenumerate(arr4):
     frame_dig 3
     frame_dig 2
@@ -2913,7 +3119,7 @@ sum_uints_and_lengths_and_trues_for_header@19:
     +
     frame_dig 2
     dig 1
-    - // on error: Index access is out of bounds
+    - // on error: index access is out of bounds
     dig 3
     len
     dig 2
@@ -2940,12 +3146,12 @@ sum_uints_and_lengths_and_trues_for_header@19:
     cover 2
     substring3
     extract 2 0
-    // tests/artifacts/Arrays/immutable.py:318
+    // tests/artifacts/Arrays/immutable.py:362
     // sum4 += dyn_tup.foo
     frame_dig 9
     uncover 2
     +
-    // tests/artifacts/Arrays/immutable.py:319
+    // tests/artifacts/Arrays/immutable.py:363
     // sum4 += dyn_tup.bar.bytes.length
     swap
     len
@@ -2953,7 +3159,7 @@ sum_uints_and_lengths_and_trues_for_header@19:
     dig 1
     +
     frame_bury 9
-    // tests/artifacts/Arrays/immutable.py:320
+    // tests/artifacts/Arrays/immutable.py:364
     // assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
     uncover 2
     ==
@@ -2962,7 +3168,7 @@ sum_uints_and_lengths_and_trues_for_header@19:
     b sum_uints_and_lengths_and_trues_for_header@19
 
 sum_uints_and_lengths_and_trues_after_for@22:
-    // tests/artifacts/Arrays/immutable.py:322
+    // tests/artifacts/Arrays/immutable.py:366
     // return sum1, sum2, sum3, sum4
     frame_dig 12
     frame_dig 11
@@ -2977,43 +3183,43 @@ sum_uints_and_lengths_and_trues_after_for@22:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_return(append: uint64) -> bytes:
 test_uint64_return:
-    // tests/artifacts/Arrays/immutable.py:324-325
+    // tests/artifacts/Arrays/immutable.py:368-369
     // @arc4.abimethod()
     // def test_uint64_return(self, append: UInt64) -> ImmutableArray[UInt64]:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:326
+    // tests/artifacts/Arrays/immutable.py:370
     // arr = ImmutableArray(UInt64(1), UInt64(2), UInt64(3))
     pushbytes 0x0003000000000000000100000000000000020000000000000003
-    // tests/artifacts/Arrays/immutable.py:327
+    // tests/artifacts/Arrays/immutable.py:371
     // for i in urange(append):
     intc_0 // 0
 
 test_uint64_return_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:327
+    // tests/artifacts/Arrays/immutable.py:371
     // for i in urange(append):
     frame_dig 1
     frame_dig -1
     <
     bz test_uint64_return_after_for@4
-    // tests/artifacts/Arrays/immutable.py:328
+    // tests/artifacts/Arrays/immutable.py:372
     // arr = arr.append(i)
-    frame_dig 0
-    extract 2 0
     frame_dig 1
     dup
-    cover 2
     itob
-    concat
+    frame_dig 0
     dup
-    len
-    intc_3 // 8
-    /
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:327
+    // tests/artifacts/Arrays/immutable.py:371
     // for i in urange(append):
     intc_1 // 1
     +
@@ -3021,43 +3227,39 @@ test_uint64_return_for_header@1:
     b test_uint64_return_for_header@1
 
 test_uint64_return_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:329
+    // tests/artifacts/Arrays/immutable.py:373
     // return arr
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_return(append: uint64) -> bytes:
 test_bool_return:
-    // tests/artifacts/Arrays/immutable.py:331-332
+    // tests/artifacts/Arrays/immutable.py:375-376
     // @arc4.abimethod()
     // def test_bool_return(self, append: UInt64) -> ImmutableArray[bool]:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:333
+    // tests/artifacts/Arrays/immutable.py:377
     // arr = ImmutableArray(True, False, True, False, True)
-    bytec_3 // 0x0000
-    pushbytes 0x8000800080
-    pushint 5 // 5
-    intc_3 // 8
-    callsub dynamic_array_concat_bits
-    // tests/artifacts/Arrays/immutable.py:334
+    pushbytes 0x0005a8
+    // tests/artifacts/Arrays/immutable.py:378
     // for i in urange(append):
     intc_0 // 0
 
 test_bool_return_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:334
+    // tests/artifacts/Arrays/immutable.py:378
     // for i in urange(append):
     frame_dig 1
     frame_dig -1
     <
     bz test_bool_return_after_for@4
-    // tests/artifacts/Arrays/immutable.py:335
+    // tests/artifacts/Arrays/immutable.py:379
     // arr = arr.append(i % 2 == 0)
     frame_dig 1
     dup
     intc_2 // 2
     %
     !
-    bytec_0 // 0x00
+    bytec_3 // 0x00
     intc_0 // 0
     uncover 2
     setbit
@@ -3067,7 +3269,7 @@ test_bool_return_for_header@1:
     intc_3 // 8
     callsub dynamic_array_concat_bits
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:334
+    // tests/artifacts/Arrays/immutable.py:378
     // for i in urange(append):
     intc_1 // 1
     +
@@ -3075,35 +3277,33 @@ test_bool_return_for_header@1:
     b test_bool_return_for_header@1
 
 test_bool_return_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:336
+    // tests/artifacts/Arrays/immutable.py:380
     // return arr
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_tuple_return(append: uint64) -> bytes:
 test_tuple_return:
-    // tests/artifacts/Arrays/immutable.py:338-339
+    // tests/artifacts/Arrays/immutable.py:382-383
     // @arc4.abimethod()
     // def test_tuple_return(self, append: UInt64) -> ImmutableArray[MyTuple]:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:340
+    // tests/artifacts/Arrays/immutable.py:384
     // arr = ImmutableArray(MyTuple(UInt64(), True, False))
     pushbytes 0x0001000000000000000080
-    // tests/artifacts/Arrays/immutable.py:341
+    // tests/artifacts/Arrays/immutable.py:385
     // for i in urange(append):
     intc_0 // 0
 
 test_tuple_return_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:341
+    // tests/artifacts/Arrays/immutable.py:385
     // for i in urange(append):
     frame_dig 1
     frame_dig -1
     <
     bz test_tuple_return_after_for@4
-    // tests/artifacts/Arrays/immutable.py:342
+    // tests/artifacts/Arrays/immutable.py:386
     // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
-    frame_dig 0
-    extract 2 0
     frame_dig 1
     dup
     intc_2 // 2
@@ -3115,27 +3315,28 @@ test_tuple_return_for_header@1:
     !
     dig 2
     itob
-    bytec_0 // 0x00
-    bytec 5 // 0x80
+    bytec_3 // 0x00
+    intc_0 // 0
     uncover 4
-    select
-    concat
-    pushint 65 // 65
-    uncover 2
     setbit
-    uncover 2
-    swap
+    intc_1 // 1
+    uncover 3
+    setbit
     concat
+    frame_dig 0
     dup
-    len
-    pushint 9 // 9
-    /
+    uncover 2
+    concat // on error: max array length exceeded
+    swap
+    intc_0 // 0
+    extract_uint16
+    intc_1 // 1
+    +
     itob
     extract 6 2
-    swap
-    concat
+    replace2 0
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:341
+    // tests/artifacts/Arrays/immutable.py:385
     // for i in urange(append):
     intc_1 // 1
     +
@@ -3143,47 +3344,49 @@ test_tuple_return_for_header@1:
     b test_tuple_return_for_header@1
 
 test_tuple_return_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:343
+    // tests/artifacts/Arrays/immutable.py:387
     // return arr
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_tuple_return(append: uint64) -> bytes:
 test_dynamic_tuple_return:
-    // tests/artifacts/Arrays/immutable.py:345-346
+    // tests/artifacts/Arrays/immutable.py:389-390
     // @arc4.abimethod()
     // def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicSizedTuple]:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:347
+    // tests/artifacts/Arrays/immutable.py:391
     // arr = ImmutableArray(MyDynamicSizedTuple(UInt64(), String("Hello")))
-    intc_0 // 0
-    bytec_2 // 0x
-    intc_1 // 1
-    pushbytes 0x00020000000000000000000a000548656c6c6f
-    callsub dynamic_array_concat_dynamic_element
-    // tests/artifacts/Arrays/immutable.py:348
+    pushbytes 0x000100020000000000000000000a000548656c6c6f
+    // tests/artifacts/Arrays/immutable.py:392
     // for i in urange(append):
     intc_0 // 0
 
 test_dynamic_tuple_return_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:348
+    // tests/artifacts/Arrays/immutable.py:392
     // for i in urange(append):
     frame_dig 1
     frame_dig -1
     <
     bz test_dynamic_tuple_return_after_for@4
-    // tests/artifacts/Arrays/immutable.py:349
+    // tests/artifacts/Arrays/immutable.py:393
     // arr = arr.append(MyDynamicSizedTuple(i, times(i)))
     frame_dig 1
     dup
     callsub times
-    dig 1
+    frame_dig 0
+    dup
+    intc_0 // 0
+    extract_uint16
+    swap
+    extract 2 0
+    dig 3
     itob
-    dig 1
+    dig 3
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 4
     concat
     swap
     bytec 6 // 0x000a
@@ -3193,17 +3396,12 @@ test_dynamic_tuple_return_for_header@1:
     bytec 4 // 0x0002
     swap
     concat
-    frame_dig 0
-    dup
-    intc_0 // 0
-    extract_uint16
-    swap
-    extract 2 0
+    cover 2
     intc_1 // 1
     uncover 3
     callsub dynamic_array_concat_dynamic_element
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:348
+    // tests/artifacts/Arrays/immutable.py:392
     // for i in urange(append):
     intc_1 // 1
     +
@@ -3211,35 +3409,35 @@ test_dynamic_tuple_return_for_header@1:
     b test_dynamic_tuple_return_for_header@1
 
 test_dynamic_tuple_return_after_for@4:
-    // tests/artifacts/Arrays/immutable.py:350
+    // tests/artifacts/Arrays/immutable.py:394
     // return arr
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_convert_to_array_and_back(arr: bytes, append: uint64) -> bytes:
 test_convert_to_array_and_back:
-    // tests/artifacts/Arrays/immutable.py:352-355
+    // tests/artifacts/Arrays/immutable.py:396-399
     // @arc4.abimethod()
     // def test_convert_to_array_and_back(
     //     self, arr: ImmutableArray[MyTuple], append: UInt64
     // ) -> ImmutableArray[MyTuple]:
     proto 2 1
-    // tests/artifacts/Arrays/immutable.py:357
+    // tests/artifacts/Arrays/immutable.py:401
     // mutable.extend(arr)
     frame_dig -2
     extract 2 0
-    // tests/artifacts/Arrays/immutable.py:358
+    // tests/artifacts/Arrays/immutable.py:402
     // for i in urange(append):
     intc_0 // 0
 
 test_convert_to_array_and_back_for_header@1:
-    // tests/artifacts/Arrays/immutable.py:358
+    // tests/artifacts/Arrays/immutable.py:402
     // for i in urange(append):
     frame_dig 1
     frame_dig -1
     <
     bz test_convert_to_array_and_back_after_for@4
-    // tests/artifacts/Arrays/immutable.py:359
+    // tests/artifacts/Arrays/immutable.py:403
     // mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
     frame_dig 1
     dup
@@ -3250,21 +3448,23 @@ test_convert_to_array_and_back_for_header@1:
     pushint 3 // 3
     %
     !
+    frame_dig 0
+    cover 3
     dig 2
     itob
-    bytec_0 // 0x00
-    bytec 5 // 0x80
+    bytec_3 // 0x00
+    intc_0 // 0
     uncover 4
-    select
+    setbit
+    intc_1 // 1
+    uncover 3
+    setbit
     concat
-    pushint 65 // 65
     uncover 2
-    setbit
-    frame_dig 0
     swap
     concat // on error: max array length exceeded
     frame_bury 0
-    // tests/artifacts/Arrays/immutable.py:358
+    // tests/artifacts/Arrays/immutable.py:402
     // for i in urange(append):
     intc_1 // 1
     +
@@ -3273,7 +3473,7 @@ test_convert_to_array_and_back_for_header@1:
 
 test_convert_to_array_and_back_after_for@4:
     frame_dig 0
-    // tests/artifacts/Arrays/immutable.py:360
+    // tests/artifacts/Arrays/immutable.py:404
     // return mutable.freeze()
     dup
     len
@@ -3289,74 +3489,68 @@ test_convert_to_array_and_back_after_for@4:
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_arc4_tuple(arg: bytes) -> bytes:
 test_concat_with_arc4_tuple:
-    // tests/artifacts/Arrays/immutable.py:362-365
+    // tests/artifacts/Arrays/immutable.py:406-409
     // @arc4.abimethod()
     // def test_concat_with_arc4_tuple(
     //     self, arg: arc4.Tuple[arc4.UInt64, arc4.UInt64]
     // ) -> ImmutableArray[arc4.UInt64]:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:367
+    // tests/artifacts/Arrays/immutable.py:410
+    // prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
+    bytec 8 // 0x000200000000000000010000000000000002
+    // tests/artifacts/Arrays/immutable.py:411
     // result = prefix + arg
-    bytec 7 // 0x00000000000000010000000000000002
     frame_dig -1
-    concat
+    concat // on error: max array length exceeded
     dup
+    extract 2 0
     len
     intc_3 // 8
     /
     itob
     extract 6 2
-    swap
-    concat
-    // tests/artifacts/Arrays/immutable.py:368
+    replace2 0
+    // tests/artifacts/Arrays/immutable.py:412
     // return result
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
 test_concat_with_native_tuple:
-    // tests/artifacts/Arrays/immutable.py:370-373
+    // tests/artifacts/Arrays/immutable.py:414-417
     // @arc4.abimethod()
     // def test_concat_with_native_tuple(
     //     self, arg: tuple[arc4.UInt64, arc4.UInt64]
     // ) -> ImmutableArray[arc4.UInt64]:
     proto 2 1
-    // tests/artifacts/Arrays/immutable.py:375
+    // tests/artifacts/Arrays/immutable.py:419
     // result = prefix + arg
     frame_dig -2
     frame_dig -1
     concat
-    bytec 7 // 0x00000000000000010000000000000002
-    swap
-    concat
-    dup
-    len
-    intc_3 // 8
-    /
-    itob
-    extract 6 2
+    // tests/artifacts/Arrays/immutable.py:418
+    // prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
+    bytec 8 // 0x000200000000000000010000000000000002
+    // tests/artifacts/Arrays/immutable.py:419
+    // result = prefix + arg
     swap
-    concat
-    // tests/artifacts/Arrays/immutable.py:376
+    concat // on error: max array length exceeded
+    pushbytes 0x0004
+    replace2 0
+    // tests/artifacts/Arrays/immutable.py:420
     // return result
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_arc4_tuple(arg: bytes) -> bytes:
 test_dynamic_concat_with_arc4_tuple:
-    // tests/artifacts/Arrays/immutable.py:378-381
+    // tests/artifacts/Arrays/immutable.py:422-425
     // @arc4.abimethod()
     // def test_dynamic_concat_with_arc4_tuple(
     //     self, arg: arc4.Tuple[arc4.String, arc4.String]
     // ) -> ImmutableArray[arc4.String]:
     proto 1 1
-    // tests/artifacts/Arrays/immutable.py:382
-    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
-    bytec_3 // 0x0000
-    bytec 8 // 0x000161000162
-    intc_2 // 2
-    callsub dynamic_array_concat_byte_length_head
-    // tests/artifacts/Arrays/immutable.py:383
+    // tests/artifacts/Arrays/immutable.py:427
     // result = prefix + arg
     frame_dig -1
     len
@@ -3364,48 +3558,54 @@ test_dynamic_concat_with_arc4_tuple:
     pushint 4 // 4
     uncover 2
     substring3
+    // tests/artifacts/Arrays/immutable.py:426
+    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
+    bytec 9 // 0x000200040007000161000162
+    // tests/artifacts/Arrays/immutable.py:427
+    // result = prefix + arg
+    swap
     intc_2 // 2
     callsub dynamic_array_concat_byte_length_head
-    // tests/artifacts/Arrays/immutable.py:384
+    // tests/artifacts/Arrays/immutable.py:428
     // return result
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
 test_dynamic_concat_with_native_tuple:
-    // tests/artifacts/Arrays/immutable.py:386-389
+    // tests/artifacts/Arrays/immutable.py:430-433
     // @arc4.abimethod()
     // def test_dynamic_concat_with_native_tuple(
     //     self, arg: tuple[arc4.String, arc4.String]
     // ) -> ImmutableArray[arc4.String]:
     proto 2 1
-    // tests/artifacts/Arrays/immutable.py:390
-    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
-    bytec_3 // 0x0000
-    bytec 8 // 0x000161000162
-    intc_2 // 2
-    callsub dynamic_array_concat_byte_length_head
-    // tests/artifacts/Arrays/immutable.py:391
+    // tests/artifacts/Arrays/immutable.py:435
     // result = prefix + arg
     frame_dig -2
     frame_dig -1
     concat
+    // tests/artifacts/Arrays/immutable.py:434
+    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
+    bytec 9 // 0x000200040007000161000162
+    // tests/artifacts/Arrays/immutable.py:435
+    // result = prefix + arg
+    swap
     intc_2 // 2
     callsub dynamic_array_concat_byte_length_head
-    // tests/artifacts/Arrays/immutable.py:392
+    // tests/artifacts/Arrays/immutable.py:436
     // return result
     retsub
 
 
 // tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_immutable_dynamic(imm1: bytes, imm2: bytes) -> bytes:
 test_concat_immutable_dynamic:
-    // tests/artifacts/Arrays/immutable.py:394-397
+    // tests/artifacts/Arrays/immutable.py:438-441
     // @arc4.abimethod()
     // def test_concat_immutable_dynamic(
     //     self, imm1: ImmutableArray[MyDynamicSizedTuple], imm2: ImmutableArray[MyDynamicSizedTuple]
     // ) -> ImmutableArray[MyDynamicSizedTuple]:
     proto 2 1
-    // tests/artifacts/Arrays/immutable.py:398
+    // tests/artifacts/Arrays/immutable.py:442
     // return imm1 + imm2
     frame_dig -2
     intc_0 // 0
@@ -3419,3 +3619,177 @@ test_concat_immutable_dynamic:
     extract 2 0
     callsub dynamic_array_concat_dynamic_element
     retsub
+
+
+// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_immutable_arc4(imm: bytes) -> bytes:
+test_immutable_arc4:
+    // tests/artifacts/Arrays/immutable.py:444-445
+    // @arc4.abimethod()
+    // def test_immutable_arc4(self, imm: ImmutableArray[MyStruct]) -> ImmutableArray[MyStruct]:
+    proto 1 1
+    // tests/artifacts/Arrays/immutable.py:446
+    // assert imm, "expected non empty array"
+    frame_dig -1
+    intc_0 // 0
+    extract_uint16
+    dup
+    assert // expected non empty array
+    // tests/artifacts/Arrays/immutable.py:447
+    // imm = imm.replace(imm.length - 1, imm[0])
+    intc_1 // 1
+    -
+    frame_dig -1
+    extract 2 16
+    swap
+    pushint 16 // 16
+    *
+    intc_2 // 2
+    +
+    frame_dig -1
+    swap
+    uncover 2
+    replace3
+    dup
+    frame_bury -1
+    // tests/artifacts/Arrays/immutable.py:448
+    // return imm
+    retsub
+
+
+// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_imm_fixed_arr() -> bytes:
+test_imm_fixed_arr:
+    // tests/artifacts/Arrays/immutable.py:450-451
+    // @arc4.abimethod()
+    // def test_imm_fixed_arr(self) -> NativeStruct3:
+    proto 0 1
+    bytec_1 // ""
+    // tests/artifacts/Arrays/immutable.py:452
+    // arr1 = zero_bytes(NativeStruct3)
+    pushint 48 // 48
+    bzero
+    dup
+    // tests/artifacts/Arrays/immutable.py:453
+    // struct12 = NativeStruct(Txn.num_app_args + 1, Txn.num_app_args + 2)
+    txn NumAppArgs
+    intc_1 // 1
+    +
+    txn NumAppArgs
+    intc_2 // 2
+    +
+    swap
+    itob
+    swap
+    itob
+    concat
+    dup
+    cover 2
+    // tests/artifacts/Arrays/immutable.py:454
+    // arr2 = NativeStruct3((struct12, struct12, struct12))
+    dup
+    dig 1
+    concat
+    swap
+    concat
+    dup
+    cover 2
+    // tests/artifacts/Arrays/immutable.py:456
+    // assert arr1 != arr2, "expected arrays to be different"
+    !=
+    assert // expected arrays to be different
+    // tests/artifacts/Arrays/immutable.py:459
+    // for i in urange(3):
+    intc_0 // 0
+
+test_imm_fixed_arr_for_header@1:
+    // tests/artifacts/Arrays/immutable.py:459
+    // for i in urange(3):
+    frame_dig 4
+    pushint 3 // 3
+    <
+    bz test_imm_fixed_arr_after_for@4
+    // tests/artifacts/Arrays/immutable.py:460
+    // arr1 = arr1.replace(i, struct12)
+    frame_dig 4
+    dup
+    pushint 16 // 16
+    *
+    frame_dig 1
+    swap
+    frame_dig 2
+    replace3
+    frame_bury 1
+    // tests/artifacts/Arrays/immutable.py:459
+    // for i in urange(3):
+    intc_1 // 1
+    +
+    frame_bury 4
+    b test_imm_fixed_arr_for_header@1
+
+test_imm_fixed_arr_after_for@4:
+    // tests/artifacts/Arrays/immutable.py:462
+    // assert arr1 == arr2, "expected arrays to be the same"
+    frame_dig 1
+    frame_dig 3
+    ==
+    assert // expected arrays to be the same
+    intc_0 // 0
+    frame_bury 0
+
+test_imm_fixed_arr_for_header@5:
+    // tests/artifacts/Arrays/immutable.py:464
+    // for struct_it in arr1:
+    frame_dig 0
+    pushint 3 // 3
+    <
+    bz test_imm_fixed_arr_after_for@8
+    frame_dig 0
+    dup
+    pushint 16 // 16
+    *
+    frame_dig 1
+    swap
+    pushint 16 // 16
+    extract3 // on error: index access is out of bounds
+    // tests/artifacts/Arrays/immutable.py:465
+    // assert struct_it == struct12, "expected items on iteration to be the same"
+    frame_dig 2
+    ==
+    assert // expected items on iteration to be the same
+    intc_1 // 1
+    +
+    frame_bury 0
+    b test_imm_fixed_arr_for_header@5
+
+test_imm_fixed_arr_after_for@8:
+    // tests/artifacts/Arrays/immutable.py:467
+    // self.imm_fixed_arr = arr1
+    bytec 10 // "imm_fixed_arr"
+    frame_dig 1
+    dup
+    cover 2
+    app_global_put
+    // tests/artifacts/Arrays/immutable.py:471
+    // assert sum_imm_fixed(mut_arr.freeze()) == 15, "expected sum to be 15"
+    dup
+    callsub sum_imm_fixed
+    pushint 15 // 15
+    ==
+    assert // expected sum to be 15
+    // tests/artifacts/Arrays/immutable.py:473
+    // mut_arr[0] = NativeStruct(UInt64(), UInt64())
+    pushbytes 0x00000000000000000000000000000000
+    replace2 0
+    // tests/artifacts/Arrays/immutable.py:474
+    // assert sum_imm_fixed(mut_arr.freeze()) == 10, "expected sum to be 10"
+    callsub sum_imm_fixed
+    pushint 10 // 10
+    ==
+    assert // expected sum to be 10
+    // tests/artifacts/Arrays/immutable.py:476
+    // return self.imm_fixed_arr
+    intc_0 // 0
+    bytec 10 // "imm_fixed_arr"
+    app_global_get_ex
+    assert // check self.imm_fixed_arr exists
+    frame_bury 0
+    retsub
diff --git a/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json b/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json
index 59f79d19..30e6e576 100644
--- a/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json
+++ b/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json
@@ -5,6 +5,11 @@
                 "no_op": "CALL"
             }
         },
+        "test_biguint_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
         "test_bool_array(uint64)void": {
             "call_config": {
                 "no_op": "CALL"
@@ -104,15 +109,25 @@
             "call_config": {
                 "no_op": "CALL"
             }
+        },
+        "test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_imm_fixed_arr()(uint64,uint64)[3]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock 0x00 0x151f7c75 0x 0x0000 0x0002 0x80 0x000a 0x00000000000000010000000000000002 0x000161000162
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@26
    pushbytess 0x44d42f99 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f // method "test_uint64_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]"
    txna ApplicationArgs 0
    match main_test_uint64_array_route@3 main_test_bool_array_route@4 main_test_fixed_size_tuple_array_route@5 main_test_fixed_size_named_tuple_array_route@6 main_test_dynamic_sized_tuple_array_route@7 main_test_dynamic_sized_named_tuple_array_route@8 main_test_implicit_conversion_log_route@9 main_test_implicit_conversion_emit_route@10 main_test_nested_array_route@11 main_test_bit_packed_tuples_route@12 main_sum_uints_and_lengths_and_trues_route@13 main_test_uint64_return_route@14 main_test_bool_return_route@15 main_test_tuple_return_route@16 main_test_dynamic_tuple_return_route@17 main_test_convert_to_array_and_back_route@18 main_test_concat_with_arc4_tuple_route@19 main_test_concat_with_native_tuple_route@20 main_test_dynamic_concat_with_arc4_tuple_route@21 main_test_dynamic_concat_with_native_tuple_route@22 main_test_concat_immutable_dynamic_route@23

main_after_if_else@30:
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    intc_0 // 0
    return

main_test_concat_immutable_dynamic_route@23:
    // tests/artifacts/Arrays/immutable.py:394
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:394
    // @arc4.abimethod()
    callsub test_concat_immutable_dynamic
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_native_tuple_route@22:
    // tests/artifacts/Arrays/immutable.py:386
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    intc_2 // 2
    extract_uint16
    dig 2
    uncover 2
    dig 2
    substring3
    dig 2
    len
    uncover 3
    uncover 3
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:386
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_native_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_arc4_tuple_route@21:
    // tests/artifacts/Arrays/immutable.py:378
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:378
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_arc4_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_native_tuple_route@20:
    // tests/artifacts/Arrays/immutable.py:370
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 8 // on error: Index access is out of bounds
    swap
    extract 8 8 // on error: Index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:370
    // @arc4.abimethod()
    callsub test_concat_with_native_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_arc4_tuple_route@19:
    // tests/artifacts/Arrays/immutable.py:362
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:362
    // @arc4.abimethod()
    callsub test_concat_with_arc4_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_convert_to_array_and_back_route@18:
    // tests/artifacts/Arrays/immutable.py:352
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/Arrays/immutable.py:352
    // @arc4.abimethod()
    callsub test_convert_to_array_and_back
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_tuple_return_route@17:
    // tests/artifacts/Arrays/immutable.py:345
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:345
    // @arc4.abimethod()
    callsub test_dynamic_tuple_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_tuple_return_route@16:
    // tests/artifacts/Arrays/immutable.py:338
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:338
    // @arc4.abimethod()
    callsub test_tuple_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bool_return_route@15:
    // tests/artifacts/Arrays/immutable.py:331
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:331
    // @arc4.abimethod()
    callsub test_bool_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_uint64_return_route@14:
    // tests/artifacts/Arrays/immutable.py:324
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:324
    // @arc4.abimethod()
    callsub test_uint64_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_sum_uints_and_lengths_and_trues_route@13:
    // tests/artifacts/Arrays/immutable.py:297
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arrays/immutable.py:297
    // @arc4.abimethod()
    callsub sum_uints_and_lengths_and_trues
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    uncover 3
    concat
    uncover 2
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bit_packed_tuples_route@12:
    // tests/artifacts/Arrays/immutable.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_bit_packed_tuples
    intc_1 // 1
    return

main_test_nested_array_route@11:
    // tests/artifacts/Arrays/immutable.py:214
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:214
    // @arc4.abimethod()
    callsub test_nested_array
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_implicit_conversion_emit_route@10:
    // tests/artifacts/Arrays/immutable.py:210
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:210
    // @arc4.abimethod()
    callsub test_implicit_conversion_emit
    intc_1 // 1
    return

main_test_implicit_conversion_log_route@9:
    // tests/artifacts/Arrays/immutable.py:206
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:206
    // @arc4.abimethod()
    callsub test_implicit_conversion_log
    intc_1 // 1
    return

main_test_dynamic_sized_named_tuple_array_route@8:
    // tests/artifacts/Arrays/immutable.py:187
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_named_tuple_array
    intc_1 // 1
    return

main_test_dynamic_sized_tuple_array_route@7:
    // tests/artifacts/Arrays/immutable.py:168
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_named_tuple_array_route@6:
    // tests/artifacts/Arrays/immutable.py:153
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_named_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_tuple_array_route@5:
    // tests/artifacts/Arrays/immutable.py:135
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_tuple_array
    intc_1 // 1
    return

main_test_bool_array_route@4:
    // tests/artifacts/Arrays/immutable.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:111
    // @arc4.abimethod()
    callsub test_bool_array
    intc_1 // 1
    return

main_test_uint64_array_route@3:
    // tests/artifacts/Arrays/immutable.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_uint64_array
    intc_1 // 1
    return

main_bare_routing@26:
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@30
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_pop_fixed_size(array: bytes, fixed_byte_size: uint64) -> bytes, bytes:
dynamic_array_pop_fixed_size:
    proto 2 2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    itob
    extract 6 0
    frame_dig -2
    swap
    replace2 0
    dup
    len
    frame_dig -1
    -
    dup2
    frame_dig -1
    extract3
    uncover 2
    intc_0 // 0
    uncover 3
    substring3
    retsub


// _puya_lib.arc4.dynamic_array_pop_dynamic_element(array: bytes) -> bytes, bytes:
dynamic_array_pop_dynamic_element:
    proto 1 2
    frame_dig -1
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dup
    intc_2 // 2
    *
    dup
    frame_dig -1
    extract 2 0
    dup
    cover 2
    dup
    uncover 2
    extract_uint16
    dup
    uncover 2
    dup
    len
    swap
    cover 2
    substring3
    bytec_2 // 0x
    intc_0 // 0

dynamic_array_pop_dynamic_element_for_header@1:
    frame_dig 6
    frame_dig 1
    <
    bz dynamic_array_pop_dynamic_element_after_for@4
    frame_dig 2
    frame_dig 6
    dup
    cover 2
    extract_uint16
    intc_2 // 2
    -
    itob
    extract 6 2
    frame_dig 5
    swap
    concat
    frame_bury 5
    intc_2 // 2
    +
    frame_bury 6
    b dynamic_array_pop_dynamic_element_for_header@1

dynamic_array_pop_dynamic_element_after_for@4:
    frame_dig 0
    itob
    extract 6 2
    frame_dig 5
    concat
    frame_dig 1
    intc_2 // 2
    +
    frame_dig 2
    swap
    frame_dig 3
    substring3
    concat
    frame_dig 4
    frame_bury 0
    frame_bury 1
    retsub


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_2 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    dup
    uncover 2
    uncover 3
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 7

dynamic_array_concat_bits_after_if_else@2:
    frame_dig 7
    frame_bury 4
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    pushint 16 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_byte_length_head(array: bytes, new_items_bytes: bytes, new_items_count: uint64) -> bytes:
dynamic_array_concat_byte_length_head:
    proto 3 1
    frame_dig -3
    intc_0 // 0
    extract_uint16
    dup
    frame_dig -1
    +
    swap
    intc_2 // 2
    *
    intc_2 // 2
    +
    dig 1
    itob
    extract 6 2
    cover 2
    frame_dig -3
    intc_2 // 2
    dig 2
    substring3
    frame_dig -1
    intc_2 // 2
    *
    bzero
    concat
    frame_dig -3
    len
    frame_dig -3
    uncover 3
    uncover 2
    substring3
    concat
    frame_dig -2
    concat
    swap
    intc_2 // 2
    *
    dup
    intc_0 // 0
    swap

dynamic_array_concat_byte_length_head_for_header@2:
    frame_dig 3
    frame_dig 2
    <
    bz dynamic_array_concat_byte_length_head_after_for@5
    frame_dig 4
    dup
    itob
    extract 6 2
    frame_dig 1
    frame_dig 3
    dup
    cover 4
    uncover 2
    replace3
    dup
    frame_bury 1
    dig 1
    extract_uint16
    intc_2 // 2
    +
    +
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 3
    b dynamic_array_concat_byte_length_head_for_header@2

dynamic_array_concat_byte_length_head_after_for@5:
    frame_dig 0
    frame_dig 1
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    bytec_2 // ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.times(n: uint64) -> bytes:
times:
    // tests/artifacts/Arrays/immutable.py:401-402
    // @subroutine
    // def times(n: UInt64) -> String:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:403
    // result = String()
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:404
    // for _i in urange(n):
    intc_0 // 0

times_for_header@1:
    // tests/artifacts/Arrays/immutable.py:404
    // for _i in urange(n):
    frame_dig 1
    frame_dig -1
    <
    bz times_after_for@4
    // tests/artifacts/Arrays/immutable.py:405
    // result += String(" ")
    frame_dig 0
    pushbytes " "
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:404
    // for _i in urange(n):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b times_for_header@1

times_after_for@4:
    // tests/artifacts/Arrays/immutable.py:406
    // return result
    retsub


// tests.artifacts.Arrays.immutable.add_x(arr: bytes, x: uint64) -> bytes:
add_x:
    // tests/artifacts/Arrays/immutable.py:409-410
    // @subroutine
    // def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:411
    // for i in urange(x):
    intc_0 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/immutable.py:411
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/immutable.py:412
    // arr = arr.append(i)
    frame_dig -2
    extract 2 0
    frame_dig 0
    dup
    cover 2
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury -2
    // tests/artifacts/Arrays/immutable.py:411
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    // tests/artifacts/Arrays/immutable.py:413
    // return arr
    frame_dig -2
    swap
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_array() -> void:
test_uint64_array:
    // tests/artifacts/Arrays/immutable.py:75-76
    // @arc4.abimethod()
    // def test_uint64_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:80
    // arr = arr.append(UInt64(42))
    pushbytes 0x0001000000000000002a
    // tests/artifacts/Arrays/immutable.py:84
    // arr = add_x(arr, UInt64(5))
    pushint 5 // 5
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:85
    // assert arr.length == 6
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:86
    // assert arr[-1] == 4
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    intc_3 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:88
    // arr = arr.append(UInt64(43))
    pushint 43 // 43
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    dupn 2
    // tests/artifacts/Arrays/immutable.py:89
    // assert arr.length == 7
    intc_0 // 0
    extract_uint16
    dup
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:90
    // assert arr[-1] == 43
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 43 // 43
    ==
    assert
    intc_2 // 2
    // tests/artifacts/Arrays/immutable.py:91
    // assert arr[0] == 42
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    intc_0 // 0

test_uint64_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    frame_dig 1
    // tests/artifacts/Arrays/immutable.py:93
    // arr = pop_x(arr, UInt64(3))
    pushint 3 // 3
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    <
    bz test_uint64_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:419
    // arr = arr.pop()
    frame_dig 0
    intc_3 // 8
    callsub dynamic_array_pop_fixed_size
    frame_bury 0
    pop
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_array_for_header@2

test_uint64_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:94
    // assert arr.length == 4
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:95
    // assert arr[-1] == 2
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    intc_2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:97
    // arr = add_x(arr, UInt64(10))
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:98
    // assert arr.length == 14
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:99
    // assert arr[-1] == 9
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    intc_3 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:101
    // arr = arr.append(UInt64(44))
    pushint 44 // 44
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:102
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:103
    // assert arr[-1] == 44
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:105
    // arr = arr.replace(2, UInt64(23))
    pushint 23 // 23
    itob
    intc_2 // 2
    uncover 2
    <
    assert // Index access is out of bounds
    replace2 18
    // tests/artifacts/Arrays/immutable.py:106
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:107
    // assert arr[2] == 23
    dup
    pushint 18 // 18
    extract_uint64
    pushint 23 // 23
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:109
    // self.a = arr
    pushbytes "a"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array(length: uint64) -> void:
test_bool_array:
    // tests/artifacts/Arrays/immutable.py:111-112
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> None:
    proto 1 0
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:113
    // arr = ImmutableArray[bool]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:116
    // for i in urange(length):
    intc_0 // 0

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:116
    // for i in urange(length):
    frame_dig 2
    frame_dig -1
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:117
    // arr = arr.append(i == Txn.num_app_args)
    txn NumAppArgs
    frame_dig 2
    dup
    uncover 2
    ==
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 1
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:116
    // for i in urange(length):
    intc_1 // 1
    +
    frame_bury 2
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:119
    // assert arr.length == length
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:121
    // if length > 0:
    frame_dig -1
    bz test_bool_array_after_if_else@6
    // tests/artifacts/Arrays/immutable.py:122
    // assert not arr[0], "expected element 0 to be False"
    frame_dig 1
    extract 2 0
    frame_dig 0
    assert // Index access is out of bounds
    intc_0 // 0
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    !
    assert // expected element 0 to be False

test_bool_array_after_if_else@6:
    // tests/artifacts/Arrays/immutable.py:123
    // if length > 1:
    frame_dig -1
    intc_1 // 1
    >
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:124
    // assert not arr[1], "expected element 1 to be False"
    frame_dig 1
    extract 2 0
    intc_1 // 1
    frame_dig 0
    <
    assert // Index access is out of bounds
    intc_1 // 1
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    !
    assert // expected element 1 to be False

test_bool_array_after_if_else@8:
    // tests/artifacts/Arrays/immutable.py:125
    // if length > 2:
    frame_dig -1
    intc_2 // 2
    >
    bz test_bool_array_after_if_else@10
    // tests/artifacts/Arrays/immutable.py:126
    // assert arr[2], "expected element 2 to be True"
    frame_dig 1
    extract 2 0
    intc_2 // 2
    frame_dig 0
    <
    assert // Index access is out of bounds
    intc_2 // 2
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    assert // expected element 2 to be True

test_bool_array_after_if_else@10:
    // tests/artifacts/Arrays/immutable.py:127
    // if length > 3:
    frame_dig -1
    pushint 3 // 3
    >
    bz test_bool_array_after_if_else@12
    // tests/artifacts/Arrays/immutable.py:128
    // assert not arr[length - 1], "expected last element to be False"
    frame_dig -1
    intc_1 // 1
    -
    frame_dig 1
    extract 2 0
    dig 1
    frame_dig 0
    <
    assert // Index access is out of bounds
    swap
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    !
    assert // expected last element to be False

test_bool_array_after_if_else@12:
    // tests/artifacts/Arrays/immutable.py:130
    // self.g = arr
    pushbytes "g"
    frame_dig 1
    app_global_put
    // tests/artifacts/Arrays/immutable.py:131
    // if length:
    frame_dig -1
    bz test_bool_array_after_if_else@14
    frame_dig 0
    intc_1 // 1
    -
    dup
    itob
    extract 6 0
    frame_dig 1
    swap
    replace2 0
    dig 1
    pushint 16 // 16
    +
    intc_0 // 0
    setbit
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    intc_2 // 2
    +
    intc_0 // 0
    swap
    substring3
    // tests/artifacts/Arrays/immutable.py:133
    // assert arr.length == length - 1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    intc_1 // 1
    -
    ==
    assert

test_bool_array_after_if_else@14:
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_tuple_array() -> void:
test_fixed_size_tuple_array:
    // tests/artifacts/Arrays/immutable.py:135-136
    // @arc4.abimethod()
    // def test_fixed_size_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:137
    // arr = ImmutableArray[tuple[UInt64, UInt64]]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:140
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:140
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:141
    // arr = arr.append((i + 1, i + 2))
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    intc_1 // 1
    +
    swap
    intc_2 // 2
    +
    dig 1
    itob
    swap
    itob
    concat
    uncover 2
    swap
    concat
    dup
    len
    pushint 16 // 16
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    frame_bury 1
    b test_fixed_size_tuple_array_for_header@1

test_fixed_size_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:143
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:144
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:145
    // assert arr[-1] == (UInt64(5), UInt64(6))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: Index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 5 // 5
    ==
    swap
    pushint 6 // 6
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:147
    // arr = arr.pop()
    pushint 16 // 16
    callsub dynamic_array_pop_fixed_size
    bury 1
    // tests/artifacts/Arrays/immutable.py:148
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:149
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:150
    // assert arr[-1] == (UInt64(4), UInt64(5))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: Index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 4 // 4
    ==
    swap
    pushint 5 // 5
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:151
    // self.c = arr
    pushbytes "c"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_named_tuple_array() -> void:
test_fixed_size_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:153-154
    // @arc4.abimethod()
    // def test_fixed_size_named_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:155
    // arr = ImmutableArray[MyTuple]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:158
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:158
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:159
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    *
    intc_2 // 2
    %
    !
    dig 2
    itob
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 4
    select
    concat
    pushint 65 // 65
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:158
    // for i in urange(5):
    intc_1 // 1
    +
    frame_bury 1
    b test_fixed_size_named_tuple_array_for_header@1

test_fixed_size_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:161
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:162
    // foo, bar, baz = arr[0]
    dup
    extract 2 9
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    // tests/artifacts/Arrays/immutable.py:163
    // assert foo == 0
    uncover 2
    !
    assert
    // tests/artifacts/Arrays/immutable.py:164
    // assert bar
    swap
    assert
    // tests/artifacts/Arrays/immutable.py:165
    // assert baz
    assert
    // tests/artifacts/Arrays/immutable.py:166
    // self.d = arr
    pushbytes "d"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_tuple_array() -> void:
test_dynamic_sized_tuple_array:
    // tests/artifacts/Arrays/immutable.py:168-169
    // @arc4.abimethod()
    // def test_dynamic_sized_tuple_array(self) -> None:
    proto 0 0
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:170
    // arr = ImmutableArray[tuple[UInt64, Bytes]]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:173
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:173
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:174
    // arr = arr.append((i + 1, op.bzero(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    bzero
    dig 1
    itob
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@1

test_dynamic_sized_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:176
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:177
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:177
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:178
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: Index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:179
    // assert arr[i][1].length == i, "expected 2nd element to be correct"
    extract 2 0
    len
    uncover 2
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@5

test_dynamic_sized_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:181
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:182
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:183
    // assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    intc_0 // 0
    bzero
    uncover 2
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:184
    // assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: Index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    pushint 3 // 3
    bzero
    uncover 2
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:185
    // self.e = arr
    pushbytes "e"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_named_tuple_array() -> void:
test_dynamic_sized_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:187-188
    // @arc4.abimethod()
    // def test_dynamic_sized_named_tuple_array(self) -> None:
    proto 0 0
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:189
    // arr = ImmutableArray[MyDynamicSizedTuple]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:192
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:192
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:193
    // arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    callsub times
    dig 1
    itob
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@1

test_dynamic_sized_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:195
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:196
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_named_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:196
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:197
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: Index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:198
    // assert arr[i][1] == times(i), "expected 2nd element to be correct"
    extract 2 0
    uncover 2
    callsub times
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@5

test_dynamic_sized_named_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:200
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:201
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:202
    // assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    swap
    bytec_2 // ""
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:203
    // assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: Index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    swap
    pushbytes "   "
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:204
    // self.f = arr
    pushbytes "f"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_log(arr: bytes) -> void:
test_implicit_conversion_log:
    // tests/artifacts/Arrays/immutable.py:206-207
    // @arc4.abimethod()
    // def test_implicit_conversion_log(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:208
    // log(arr)
    frame_dig -1
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_emit(arr: bytes) -> void:
test_implicit_conversion_emit:
    // tests/artifacts/Arrays/immutable.py:210-211
    // @arc4.abimethod()
    // def test_implicit_conversion_emit(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:212
    // arc4.emit("emit_test", arr)
    bytec 4 // 0x0002
    frame_dig -1
    concat
    pushbytes 0xfa40c053 // method "emit_test(uint64[])"
    swap
    concat
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_nested_array(arr_to_add: uint64, arr: bytes) -> bytes:
test_nested_array:
    // tests/artifacts/Arrays/immutable.py:214-217
    // @arc4.abimethod()
    // def test_nested_array(
    //     self, arr_to_add: UInt64, arr: ImmutableArray[ImmutableArray[UInt64]]
    // ) -> ImmutableArray[UInt64]:
    proto 2 1
    intc_0 // 0
    dupn 3
    bytec_2 // ""
    dupn 5
    // tests/artifacts/Arrays/immutable.py:218-219
    // # add n new arrays
    // for i in urange(arr_to_add):
    intc_0 // 0

test_nested_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:218-219
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 10
    frame_dig -2
    <
    bz test_nested_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:220
    // extra_arr = ImmutableArray[UInt64]()
    bytec_3 // 0x0000
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:221
    // for j in urange(i):
    intc_0 // 0
    frame_bury 8

test_nested_array_for_header@3:
    // tests/artifacts/Arrays/immutable.py:221
    // for j in urange(i):
    frame_dig 8
    frame_dig 10
    <
    bz test_nested_array_after_for@6
    // tests/artifacts/Arrays/immutable.py:222
    // extra_arr = extra_arr.append(j)
    frame_dig 1
    extract 2 0
    frame_dig 8
    dup
    cover 2
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:221
    // for j in urange(i):
    intc_1 // 1
    +
    frame_bury 8
    b test_nested_array_for_header@3

test_nested_array_after_for@6:
    // tests/artifacts/Arrays/immutable.py:223
    // arr = arr.append(extra_arr)
    bytec 4 // 0x0002
    frame_dig 1
    concat
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury -1
    // tests/artifacts/Arrays/immutable.py:218-219
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 10
    b test_nested_array_for_header@1

test_nested_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:225-226
    // # sum inner arrays and return an array containing sums
    // totals = ImmutableArray[UInt64]()
    bytec_3 // 0x0000
    frame_bury 3
    // tests/artifacts/Arrays/immutable.py:227
    // for inner_arr in arr:
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 4
    intc_0 // 0
    frame_bury 6

test_nested_array_for_header@9:
    // tests/artifacts/Arrays/immutable.py:227
    // for inner_arr in arr:
    frame_dig 6
    frame_dig 4
    <
    bz test_nested_array_after_for@12
    frame_dig -1
    extract 2 0
    frame_dig 6
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dup2
    extract_uint16
    intc_3 // 8
    *
    intc_2 // 2
    +
    extract3
    dup
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:228
    // totals = totals.append(sum_arr(inner_arr))
    frame_dig 3
    extract 2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:425
    // total = UInt64()
    intc_0 // 0
    frame_bury 9
    // tests/artifacts/Arrays/immutable.py:426
    // for i in arr:
    intc_0 // 0
    extract_uint16
    frame_bury 5
    intc_0 // 0
    frame_bury 7

test_nested_array_for_header@14:
    // tests/artifacts/Arrays/immutable.py:426
    // for i in arr:
    frame_dig 7
    frame_dig 5
    <
    bz test_nested_array_after_for@16
    frame_dig 2
    extract 2 0
    frame_dig 7
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:427
    // total += i
    frame_dig 9
    +
    frame_bury 9
    intc_1 // 1
    +
    frame_bury 7
    b test_nested_array_for_header@14

test_nested_array_after_for@16:
    // tests/artifacts/Arrays/immutable.py:428
    // return total
    frame_dig 9
    itob
    // tests/artifacts/Arrays/immutable.py:228
    // totals = totals.append(sum_arr(inner_arr))
    frame_dig 0
    swap
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 3
    frame_dig 6
    intc_1 // 1
    +
    frame_bury 6
    b test_nested_array_for_header@9

test_nested_array_after_for@12:
    // tests/artifacts/Arrays/immutable.py:230
    // return totals
    frame_dig 3
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bit_packed_tuples() -> void:
test_bit_packed_tuples:
    // tests/artifacts/Arrays/immutable.py:232-233
    // @arc4.abimethod()
    // def test_bit_packed_tuples(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:234
    // arr2 = ImmutableArray[TwoBoolTuple]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:235-237
    // arr7 = ImmutableArray[SevenBoolTuple]()
    // arr8 = ImmutableArray[EightBoolTuple]()
    // arr9 = ImmutableArray[NineBoolTuple]()
    dupn 3
    // tests/artifacts/Arrays/immutable.py:243
    // for i in urange(5):
    intc_0 // 0

test_bit_packed_tuples_for_header@1:
    // tests/artifacts/Arrays/immutable.py:243
    // for i in urange(5):
    frame_dig 4
    pushint 5 // 5
    <
    bz test_bit_packed_tuples_after_for@4
    // tests/artifacts/Arrays/immutable.py:244
    // arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
    frame_dig 0
    extract 2 0
    frame_dig 4
    dup
    !
    dig 1
    intc_1 // 1
    ==
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 3
    select
    dup
    intc_1 // 1
    dig 3
    setbit
    uncover 4
    swap
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:245-257
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    frame_dig 1
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:251
    // c=i == 2,
    dig 3
    intc_2 // 2
    ==
    // tests/artifacts/Arrays/immutable.py:252
    // d=i == 3,
    dig 4
    pushint 3 // 3
    ==
    // tests/artifacts/Arrays/immutable.py:253
    // e=i == 4,
    dig 5
    pushint 4 // 4
    ==
    // tests/artifacts/Arrays/immutable.py:254
    // f=i == 5,
    dig 6
    pushint 5 // 5
    ==
    // tests/artifacts/Arrays/immutable.py:255
    // g=i == 6,
    dig 7
    pushint 6 // 6
    ==
    // tests/artifacts/Arrays/immutable.py:248
    // bar=i + 1,
    dig 8
    intc_1 // 1
    +
    // tests/artifacts/Arrays/immutable.py:247
    // foo=i,
    dig 9
    itob
    uncover 8
    concat
    pushint 65 // 65
    uncover 9
    setbit
    pushint 66 // 66
    uncover 7
    setbit
    pushint 67 // 67
    uncover 6
    setbit
    pushint 68 // 68
    uncover 5
    setbit
    pushint 69 // 69
    uncover 4
    setbit
    pushint 70 // 70
    uncover 3
    setbit
    dig 1
    itob
    dup2
    concat
    // tests/artifacts/Arrays/immutable.py:245-257
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    uncover 4
    swap
    concat
    dup
    len
    pushint 17 // 17
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:258-271
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    frame_dig 2
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:269
    // h=i == 7,
    dig 4
    pushint 7 // 7
    ==
    // tests/artifacts/Arrays/immutable.py:260
    // foo=i,
    uncover 3
    pushint 71 // 71
    uncover 2
    setbit
    dup
    dig 3
    concat
    // tests/artifacts/Arrays/immutable.py:258-271
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    uncover 2
    swap
    concat
    dup
    len
    pushint 17 // 17
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:272-286
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    frame_dig 3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:284
    // i=i == 8,
    uncover 4
    intc_3 // 8
    ==
    // tests/artifacts/Arrays/immutable.py:274
    // foo=i,
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    uncover 2
    swap
    concat
    uncover 2
    concat
    // tests/artifacts/Arrays/immutable.py:272-286
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    concat
    dup
    len
    pushint 18 // 18
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 3
    frame_bury 4
    b test_bit_packed_tuples_for_header@1

test_bit_packed_tuples_after_for@4:
    // tests/artifacts/Arrays/immutable.py:288
    // assert arr2.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:289
    // assert arr7.length == 5
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:290
    // assert arr8.length == 5
    frame_dig 2
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:291
    // assert arr9.length == 5
    frame_dig 3
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:292
    // self.bool2 = arr2
    pushbytes "bool2"
    uncover 4
    app_global_put
    // tests/artifacts/Arrays/immutable.py:293
    // self.bool7 = arr7
    pushbytes "bool7"
    uncover 3
    app_global_put
    // tests/artifacts/Arrays/immutable.py:294
    // self.bool8 = arr8
    pushbytes "bool8"
    uncover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:295
    // self.bool9 = arr9
    pushbytes "bool9"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.sum_uints_and_lengths_and_trues(arr1: bytes, arr2: bytes, arr3: bytes, arr4: bytes) -> uint64, uint64, uint64, uint64:
sum_uints_and_lengths_and_trues:
    // tests/artifacts/Arrays/immutable.py:297-304
    // @arc4.abimethod()
    // def sum_uints_and_lengths_and_trues(
    //     self,
    //     arr1: ImmutableArray[UInt64],
    //     arr2: ImmutableArray[bool],
    //     arr3: ImmutableArray[MyTuple],
    //     arr4: ImmutableArray[MyDynamicSizedTuple],
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    bytec_2 // ""
    dupn 8
    // tests/artifacts/Arrays/immutable.py:305
    // sum1 = sum2 = sum3 = sum4 = UInt64()
    intc_0 // 0
    dupn 3
    // tests/artifacts/Arrays/immutable.py:306
    // for i in arr1:
    frame_dig -4
    intc_0 // 0
    extract_uint16
    intc_0 // 0

sum_uints_and_lengths_and_trues_for_header@1:
    // tests/artifacts/Arrays/immutable.py:306
    // for i in arr1:
    frame_dig 14
    frame_dig 13
    <
    bz sum_uints_and_lengths_and_trues_after_for@4
    frame_dig -4
    extract 2 0
    frame_dig 14
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:307
    // sum1 += i
    frame_dig 12
    +
    frame_bury 12
    intc_1 // 1
    +
    frame_bury 14
    b sum_uints_and_lengths_and_trues_for_header@1

sum_uints_and_lengths_and_trues_after_for@4:
    // tests/artifacts/Arrays/immutable.py:308
    // for b in arr2:
    frame_dig -3
    intc_0 // 0
    extract_uint16
    frame_bury 0
    intc_0 // 0
    frame_bury 4

sum_uints_and_lengths_and_trues_for_header@5:
    // tests/artifacts/Arrays/immutable.py:308
    // for b in arr2:
    frame_dig 4
    frame_dig 0
    <
    bz sum_uints_and_lengths_and_trues_after_for@10
    frame_dig -3
    extract 2 0
    frame_dig 4
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    frame_dig 11
    frame_bury 6
    // tests/artifacts/Arrays/immutable.py:309
    // if b:
    bz sum_uints_and_lengths_and_trues_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:310
    // sum2 += 1
    frame_dig 11
    intc_1 // 1
    +
    frame_bury 6

sum_uints_and_lengths_and_trues_after_if_else@8:
    frame_dig 6
    frame_bury 11
    frame_dig 4
    intc_1 // 1
    +
    frame_bury 4
    b sum_uints_and_lengths_and_trues_for_header@5

sum_uints_and_lengths_and_trues_after_for@10:
    // tests/artifacts/Arrays/immutable.py:311
    // for tup in arr3:
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_bury 1
    intc_0 // 0
    frame_bury 5

sum_uints_and_lengths_and_trues_for_header@11:
    // tests/artifacts/Arrays/immutable.py:311
    // for tup in arr3:
    frame_dig 5
    frame_dig 1
    <
    bz sum_uints_and_lengths_and_trues_after_for@18
    frame_dig -2
    extract 2 0
    frame_dig 5
    pushint 9 // 9
    *
    pushint 9 // 9
    extract3 // on error: Index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    frame_bury 8
    // tests/artifacts/Arrays/immutable.py:312
    // sum3 += tup.foo
    frame_dig 10
    uncover 2
    +
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:313
    // if tup.bar:
    bz sum_uints_and_lengths_and_trues_after_if_else@14
    // tests/artifacts/Arrays/immutable.py:314
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@14:
    frame_dig 7
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:315
    // if tup.baz:
    frame_dig 8
    bz sum_uints_and_lengths_and_trues_after_if_else@16
    // tests/artifacts/Arrays/immutable.py:316
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@16:
    frame_dig 7
    frame_bury 10
    frame_dig 5
    intc_1 // 1
    +
    frame_bury 5
    b sum_uints_and_lengths_and_trues_for_header@11

sum_uints_and_lengths_and_trues_after_for@18:
    // tests/artifacts/Arrays/immutable.py:317
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 2
    intc_0 // 0
    frame_bury 3

sum_uints_and_lengths_and_trues_for_header@19:
    // tests/artifacts/Arrays/immutable.py:317
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig 3
    frame_dig 2
    <
    bz sum_uints_and_lengths_and_trues_after_for@22
    frame_dig -1
    extract 2 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 2
    dig 1
    - // on error: Index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:318
    // sum4 += dyn_tup.foo
    frame_dig 9
    uncover 2
    +
    // tests/artifacts/Arrays/immutable.py:319
    // sum4 += dyn_tup.bar.bytes.length
    swap
    len
    swap
    dig 1
    +
    frame_bury 9
    // tests/artifacts/Arrays/immutable.py:320
    // assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
    uncover 2
    ==
    assert // expected string length to match index
    frame_bury 3
    b sum_uints_and_lengths_and_trues_for_header@19

sum_uints_and_lengths_and_trues_after_for@22:
    // tests/artifacts/Arrays/immutable.py:322
    // return sum1, sum2, sum3, sum4
    frame_dig 12
    frame_dig 11
    frame_dig 10
    frame_dig 9
    frame_bury 3
    frame_bury 2
    frame_bury 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_return(append: uint64) -> bytes:
test_uint64_return:
    // tests/artifacts/Arrays/immutable.py:324-325
    // @arc4.abimethod()
    // def test_uint64_return(self, append: UInt64) -> ImmutableArray[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:326
    // arr = ImmutableArray(UInt64(1), UInt64(2), UInt64(3))
    pushbytes 0x0003000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:327
    // for i in urange(append):
    intc_0 // 0

test_uint64_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:327
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_uint64_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:328
    // arr = arr.append(i)
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    cover 2
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:327
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_return_for_header@1

test_uint64_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:329
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_return(append: uint64) -> bytes:
test_bool_return:
    // tests/artifacts/Arrays/immutable.py:331-332
    // @arc4.abimethod()
    // def test_bool_return(self, append: UInt64) -> ImmutableArray[bool]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:333
    // arr = ImmutableArray(True, False, True, False, True)
    bytec_3 // 0x0000
    pushbytes 0x8000800080
    pushint 5 // 5
    intc_3 // 8
    callsub dynamic_array_concat_bits
    // tests/artifacts/Arrays/immutable.py:334
    // for i in urange(append):
    intc_0 // 0

test_bool_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:334
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_bool_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:335
    // arr = arr.append(i % 2 == 0)
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 0
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:334
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_bool_return_for_header@1

test_bool_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:336
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_tuple_return(append: uint64) -> bytes:
test_tuple_return:
    // tests/artifacts/Arrays/immutable.py:338-339
    // @arc4.abimethod()
    // def test_tuple_return(self, append: UInt64) -> ImmutableArray[MyTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:340
    // arr = ImmutableArray(MyTuple(UInt64(), True, False))
    pushbytes 0x0001000000000000000080
    // tests/artifacts/Arrays/immutable.py:341
    // for i in urange(append):
    intc_0 // 0

test_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:341
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:342
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    dig 2
    itob
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 4
    select
    concat
    pushint 65 // 65
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:341
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_tuple_return_for_header@1

test_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:343
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_tuple_return(append: uint64) -> bytes:
test_dynamic_tuple_return:
    // tests/artifacts/Arrays/immutable.py:345-346
    // @arc4.abimethod()
    // def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:347
    // arr = ImmutableArray(MyDynamicSizedTuple(UInt64(), String("Hello")))
    intc_0 // 0
    bytec_2 // 0x
    intc_1 // 1
    pushbytes 0x00020000000000000000000a000548656c6c6f
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/Arrays/immutable.py:348
    // for i in urange(append):
    intc_0 // 0

test_dynamic_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:348
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_dynamic_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:349
    // arr = arr.append(MyDynamicSizedTuple(i, times(i)))
    frame_dig 1
    dup
    callsub times
    dig 1
    itob
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:348
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_dynamic_tuple_return_for_header@1

test_dynamic_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:350
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_convert_to_array_and_back(arr: bytes, append: uint64) -> bytes:
test_convert_to_array_and_back:
    // tests/artifacts/Arrays/immutable.py:352-355
    // @arc4.abimethod()
    // def test_convert_to_array_and_back(
    //     self, arr: ImmutableArray[MyTuple], append: UInt64
    // ) -> ImmutableArray[MyTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:357
    // mutable.extend(arr)
    frame_dig -2
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:358
    // for i in urange(append):
    intc_0 // 0

test_convert_to_array_and_back_for_header@1:
    // tests/artifacts/Arrays/immutable.py:358
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_convert_to_array_and_back_after_for@4
    // tests/artifacts/Arrays/immutable.py:359
    // mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    dig 2
    itob
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 4
    select
    concat
    pushint 65 // 65
    uncover 2
    setbit
    frame_dig 0
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:358
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_convert_to_array_and_back_for_header@1

test_convert_to_array_and_back_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/immutable.py:360
    // return mutable.freeze()
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:362-365
    // @arc4.abimethod()
    // def test_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:367
    // result = prefix + arg
    bytec 7 // 0x00000000000000010000000000000002
    frame_dig -1
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:368
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:370-373
    // @arc4.abimethod()
    // def test_concat_with_native_tuple(
    //     self, arg: tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:375
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    bytec 7 // 0x00000000000000010000000000000002
    swap
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:376
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_dynamic_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:378-381
    // @arc4.abimethod()
    // def test_dynamic_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:382
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec_3 // 0x0000
    bytec 8 // 0x000161000162
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:383
    // result = prefix + arg
    frame_dig -1
    len
    frame_dig -1
    pushint 4 // 4
    uncover 2
    substring3
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:384
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_dynamic_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:386-389
    // @arc4.abimethod()
    // def test_dynamic_concat_with_native_tuple(
    //     self, arg: tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:390
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec_3 // 0x0000
    bytec 8 // 0x000161000162
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:391
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:392
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_immutable_dynamic(imm1: bytes, imm2: bytes) -> bytes:
test_concat_immutable_dynamic:
    // tests/artifacts/Arrays/immutable.py:394-397
    // @arc4.abimethod()
    // def test_concat_immutable_dynamic(
    //     self, imm1: ImmutableArray[MyDynamicSizedTuple], imm2: ImmutableArray[MyDynamicSizedTuple]
    // ) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:398
    // return imm1 + imm2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_dig -2
    extract 2 0
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    callsub dynamic_array_concat_dynamic_element
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock 0x151f7c75 0x 0x0000 0x00 0x0002 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0x000a 0x62696775696e74 0x000200000000000000010000000000000002 0x000200040007000161000162 "imm_fixed_arr"
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@29
    pushbytess 0x44d42f99 0xb7eaa60b 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f 0x6d4aa358 0xb7cb96bd // method "test_uint64_array()void", method "test_biguint_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]", method "test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]", method "test_imm_fixed_arr()(uint64,uint64)[3]"
    txna ApplicationArgs 0
    match main_test_uint64_array_route@3 main_test_biguint_array_route@4 main_test_bool_array_route@5 main_test_fixed_size_tuple_array_route@6 main_test_fixed_size_named_tuple_array_route@7 main_test_dynamic_sized_tuple_array_route@8 main_test_dynamic_sized_named_tuple_array_route@9 main_test_implicit_conversion_log_route@10 main_test_implicit_conversion_emit_route@11 main_test_nested_array_route@12 main_test_bit_packed_tuples_route@13 main_sum_uints_and_lengths_and_trues_route@14 main_test_uint64_return_route@15 main_test_bool_return_route@16 main_test_tuple_return_route@17 main_test_dynamic_tuple_return_route@18 main_test_convert_to_array_and_back_route@19 main_test_concat_with_arc4_tuple_route@20 main_test_concat_with_native_tuple_route@21 main_test_dynamic_concat_with_arc4_tuple_route@22 main_test_dynamic_concat_with_native_tuple_route@23 main_test_concat_immutable_dynamic_route@24 main_test_immutable_arc4_route@25 main_test_imm_fixed_arr_route@26

main_after_if_else@33:
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    intc_0 // 0
    return

main_test_imm_fixed_arr_route@26:
    // tests/artifacts/Arrays/immutable.py:450
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_imm_fixed_arr
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_immutable_arc4_route@25:
    // tests/artifacts/Arrays/immutable.py:444
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:444
    // @arc4.abimethod()
    callsub test_immutable_arc4
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_immutable_dynamic_route@24:
    // tests/artifacts/Arrays/immutable.py:438
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:438
    // @arc4.abimethod()
    callsub test_concat_immutable_dynamic
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_native_tuple_route@23:
    // tests/artifacts/Arrays/immutable.py:430
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    intc_2 // 2
    extract_uint16
    dig 2
    uncover 2
    dig 2
    substring3
    dig 2
    len
    uncover 3
    uncover 3
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:430
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_native_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_arc4_tuple_route@22:
    // tests/artifacts/Arrays/immutable.py:422
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:422
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_arc4_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_native_tuple_route@21:
    // tests/artifacts/Arrays/immutable.py:414
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 8
    swap
    extract 8 8
    // tests/artifacts/Arrays/immutable.py:414
    // @arc4.abimethod()
    callsub test_concat_with_native_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_arc4_tuple_route@20:
    // tests/artifacts/Arrays/immutable.py:406
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:406
    // @arc4.abimethod()
    callsub test_concat_with_arc4_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_convert_to_array_and_back_route@19:
    // tests/artifacts/Arrays/immutable.py:396
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/Arrays/immutable.py:396
    // @arc4.abimethod()
    callsub test_convert_to_array_and_back
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_tuple_return_route@18:
    // tests/artifacts/Arrays/immutable.py:389
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:389
    // @arc4.abimethod()
    callsub test_dynamic_tuple_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_tuple_return_route@17:
    // tests/artifacts/Arrays/immutable.py:382
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:382
    // @arc4.abimethod()
    callsub test_tuple_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bool_return_route@16:
    // tests/artifacts/Arrays/immutable.py:375
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:375
    // @arc4.abimethod()
    callsub test_bool_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_uint64_return_route@15:
    // tests/artifacts/Arrays/immutable.py:368
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:368
    // @arc4.abimethod()
    callsub test_uint64_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_sum_uints_and_lengths_and_trues_route@14:
    // tests/artifacts/Arrays/immutable.py:341
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arrays/immutable.py:341
    // @arc4.abimethod()
    callsub sum_uints_and_lengths_and_trues
    uncover 3
    itob
    uncover 3
    itob
    concat
    uncover 2
    itob
    concat
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bit_packed_tuples_route@13:
    // tests/artifacts/Arrays/immutable.py:276
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_bit_packed_tuples
    intc_1 // 1
    return

main_test_nested_array_route@12:
    // tests/artifacts/Arrays/immutable.py:258
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:258
    // @arc4.abimethod()
    callsub test_nested_array
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_implicit_conversion_emit_route@11:
    // tests/artifacts/Arrays/immutable.py:254
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:254
    // @arc4.abimethod()
    callsub test_implicit_conversion_emit
    intc_1 // 1
    return

main_test_implicit_conversion_log_route@10:
    // tests/artifacts/Arrays/immutable.py:250
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:250
    // @arc4.abimethod()
    callsub test_implicit_conversion_log
    intc_1 // 1
    return

main_test_dynamic_sized_named_tuple_array_route@9:
    // tests/artifacts/Arrays/immutable.py:231
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_named_tuple_array
    intc_1 // 1
    return

main_test_dynamic_sized_tuple_array_route@8:
    // tests/artifacts/Arrays/immutable.py:212
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_named_tuple_array_route@7:
    // tests/artifacts/Arrays/immutable.py:197
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_named_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_tuple_array_route@6:
    // tests/artifacts/Arrays/immutable.py:179
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_tuple_array
    intc_1 // 1
    return

main_test_bool_array_route@5:
    // tests/artifacts/Arrays/immutable.py:155
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:155
    // @arc4.abimethod()
    callsub test_bool_array
    intc_1 // 1
    return

main_test_biguint_array_route@4:
    // tests/artifacts/Arrays/immutable.py:130
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_biguint_array
    intc_1 // 1
    return

main_test_uint64_array_route@3:
    // tests/artifacts/Arrays/immutable.py:94
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_uint64_array
    intc_1 // 1
    return

main_bare_routing@29:
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@33
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_pop_fixed_size(array: bytes, fixed_byte_size: uint64) -> bytes, bytes:
dynamic_array_pop_fixed_size:
    proto 2 2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    itob
    extract 6 0
    frame_dig -2
    swap
    replace2 0
    dup
    len
    frame_dig -1
    -
    dup2
    frame_dig -1
    extract3
    uncover 2
    intc_0 // 0
    uncover 3
    substring3
    retsub


// _puya_lib.arc4.dynamic_array_pop_dynamic_element(array: bytes) -> bytes, bytes:
dynamic_array_pop_dynamic_element:
    proto 1 2
    frame_dig -1
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dup
    intc_2 // 2
    *
    dup
    frame_dig -1
    extract 2 0
    dup
    cover 2
    dup
    uncover 2
    extract_uint16
    dup
    uncover 2
    dup
    len
    swap
    cover 2
    substring3
    bytec_1 // 0x
    intc_0 // 0

dynamic_array_pop_dynamic_element_for_header@1:
    frame_dig 6
    frame_dig 1
    <
    bz dynamic_array_pop_dynamic_element_after_for@4
    frame_dig 2
    frame_dig 6
    dup
    cover 2
    extract_uint16
    intc_2 // 2
    -
    itob
    extract 6 2
    frame_dig 5
    swap
    concat
    frame_bury 5
    intc_2 // 2
    +
    frame_bury 6
    b dynamic_array_pop_dynamic_element_for_header@1

dynamic_array_pop_dynamic_element_after_for@4:
    frame_dig 0
    itob
    extract 6 2
    frame_dig 5
    concat
    frame_dig 1
    intc_2 // 2
    +
    frame_dig 2
    swap
    frame_dig 3
    substring3
    concat
    frame_dig 4
    frame_bury 0
    frame_bury 1
    retsub


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_1 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    dup
    uncover 2
    uncover 3
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 7

dynamic_array_concat_bits_after_if_else@2:
    frame_dig 7
    frame_bury 4
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    pushint 16 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_byte_length_head(array: bytes, new_items_bytes: bytes, new_items_count: uint64) -> bytes:
dynamic_array_concat_byte_length_head:
    proto 3 1
    frame_dig -3
    intc_0 // 0
    extract_uint16
    dup
    frame_dig -1
    +
    swap
    intc_2 // 2
    *
    intc_2 // 2
    +
    dig 1
    itob
    extract 6 2
    cover 2
    frame_dig -3
    intc_2 // 2
    dig 2
    substring3
    frame_dig -1
    intc_2 // 2
    *
    bzero
    concat
    frame_dig -3
    len
    frame_dig -3
    uncover 3
    uncover 2
    substring3
    concat
    frame_dig -2
    concat
    swap
    intc_2 // 2
    *
    dup
    intc_0 // 0
    swap

dynamic_array_concat_byte_length_head_for_header@2:
    frame_dig 3
    frame_dig 2
    <
    bz dynamic_array_concat_byte_length_head_after_for@4
    frame_dig 4
    dup
    itob
    extract 6 2
    frame_dig 1
    frame_dig 3
    dup
    cover 4
    uncover 2
    replace3
    dup
    frame_bury 1
    dig 1
    extract_uint16
    intc_2 // 2
    +
    +
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 3
    b dynamic_array_concat_byte_length_head_for_header@2

dynamic_array_concat_byte_length_head_after_for@4:
    frame_dig 0
    frame_dig 1
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    bytec_1 // ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.sum_imm_fixed(arr: bytes) -> uint64:
sum_imm_fixed:
    // tests/artifacts/Arrays/immutable.py:479-480
    // @subroutine
    // def sum_imm_fixed(arr: NativeStruct3) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:481
    // total = UInt64(0)
    intc_0 // 0
    dup

sum_imm_fixed_for_header@1:
    // tests/artifacts/Arrays/immutable.py:482
    // for item in arr:
    frame_dig 1
    pushint 3 // 3
    <
    bz sum_imm_fixed_after_for@4
    // tests/artifacts/Arrays/immutable.py:482-483
    // for item in arr:
    //     total += item.foo
    frame_dig 1
    dup
    pushint 16 // 16
    *
    frame_dig -1
    swap
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:483
    // total += item.foo
    dup
    // tests/artifacts/Arrays/immutable.py:482-483
    // for item in arr:
    //     total += item.foo
    intc_0 // 0
    // tests/artifacts/Arrays/immutable.py:483
    // total += item.foo
    extract_uint64
    frame_dig 0
    +
    // tests/artifacts/Arrays/immutable.py:484
    // total += item.bar
    swap
    intc_3 // 8
    extract_uint64
    +
    frame_bury 0
    intc_1 // 1
    +
    frame_bury 1
    b sum_imm_fixed_for_header@1

sum_imm_fixed_after_for@4:
    // tests/artifacts/Arrays/immutable.py:485
    // return total
    retsub


// tests.artifacts.Arrays.immutable.times(n: uint64) -> bytes:
times:
    // tests/artifacts/Arrays/immutable.py:488-489
    // @subroutine
    // def times(n: UInt64) -> String:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:490
    // result = String()
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:491
    // for _i in urange(n):
    intc_0 // 0

times_for_header@1:
    // tests/artifacts/Arrays/immutable.py:491
    // for _i in urange(n):
    frame_dig 1
    frame_dig -1
    <
    bz times_after_for@4
    // tests/artifacts/Arrays/immutable.py:492
    // result += String(" ")
    frame_dig 0
    pushbytes " "
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:491
    // for _i in urange(n):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b times_for_header@1

times_after_for@4:
    // tests/artifacts/Arrays/immutable.py:493
    // return result
    retsub


// tests.artifacts.Arrays.immutable.add_x(arr: bytes, x: uint64) -> bytes:
add_x:
    // tests/artifacts/Arrays/immutable.py:496-497
    // @subroutine
    // def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:498
    // for i in urange(x):
    intc_0 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/immutable.py:498
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/immutable.py:499
    // arr = arr.append(i)
    frame_dig 0
    dup
    itob
    frame_dig -2
    swap
    concat // on error: max array length exceeded
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury -2
    // tests/artifacts/Arrays/immutable.py:498
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    // tests/artifacts/Arrays/immutable.py:500
    // return arr
    frame_dig -2
    swap
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_array() -> void:
test_uint64_array:
    // tests/artifacts/Arrays/immutable.py:94-95
    // @arc4.abimethod()
    // def test_uint64_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:99
    // arr = arr.append(UInt64(42))
    pushbytes 0x0001000000000000002a
    // tests/artifacts/Arrays/immutable.py:103
    // arr = add_x(arr, UInt64(5))
    pushint 5 // 5
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:104
    // assert arr.length == 6
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:105
    // assert arr[-1] == 4
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:107
    // arr = arr.append(UInt64(43))
    pushint 43 // 43
    itob
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    dupn 2
    // tests/artifacts/Arrays/immutable.py:108
    // assert arr.length == 7
    intc_0 // 0
    extract_uint16
    dup
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:109
    // assert arr[-1] == 43
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 43 // 43
    ==
    assert
    intc_2 // 2
    // tests/artifacts/Arrays/immutable.py:110
    // assert arr[0] == 42
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    intc_0 // 0

test_uint64_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    frame_dig 1
    // tests/artifacts/Arrays/immutable.py:112
    // arr = pop_x(arr, UInt64(3))
    pushint 3 // 3
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    <
    bz test_uint64_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:506
    // arr = arr.pop()
    frame_dig 0
    intc_3 // 8
    callsub dynamic_array_pop_fixed_size
    frame_bury 0
    pop
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_array_for_header@2

test_uint64_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:113
    // assert arr.length == 4
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:114
    // assert arr[-1] == 2
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    intc_2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:116
    // arr = add_x(arr, UInt64(10))
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:117
    // assert arr.length == 14
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:118
    // assert arr[-1] == 9
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:120
    // arr = arr.append(UInt64(44))
    pushint 44 // 44
    itob
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:121
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:122
    // assert arr[-1] == 44
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:124
    // arr = arr.replace(2, UInt64(23))
    pushint 23 // 23
    itob
    replace2 18
    // tests/artifacts/Arrays/immutable.py:125
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:126
    // assert arr[2] == 23
    dup
    pushint 18 // 18
    extract_uint64
    pushint 23 // 23
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:128
    // self.a = arr
    pushbytes "a"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_biguint_array() -> void:
test_biguint_array:
    // tests/artifacts/Arrays/immutable.py:130-131
    // @arc4.abimethod()
    // def test_biguint_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:135
    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
    txn NumAppArgs
    intc_1 // 1
    -
    itob
    pushint 64 // 64
    bzero
    dup
    cover 2
    b|
    // tests/artifacts/Arrays/immutable.py:132
    // arr = ImmutableArray[BigUInt]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:135
    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
    swap
    concat // on error: max array length exceeded
    pushbytes 0x0001
    replace2 0
    dupn 2
    // tests/artifacts/Arrays/immutable.py:136
    // assert arr.length == 1
    intc_0 // 0
    extract_uint16
    dup
    intc_1 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:137
    // assert arr[-1] == 0
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    bytec_1 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    intc_0 // 0

test_biguint_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    frame_dig 2
    // tests/artifacts/Arrays/immutable.py:139
    // arr = add_xb(arr, UInt64(5))
    pushint 5 // 5
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    <
    bz test_biguint_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:513
    // arr = arr.append(BigUInt(i))
    frame_dig 2
    dup
    itob
    frame_dig 0
    b|
    frame_dig 1
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 2
    b test_biguint_array_for_header@2

test_biguint_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:140
    // assert arr.length == 6
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:141
    // assert arr[-1] == 4
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    pushbytes 0x04
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:143
    // arr = arr.append(BigUInt(2**512 - 1) - Txn.num_app_args)
    txn NumAppArgs
    itob
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    swap
    b-
    dup
    len
    pushint 64 // 64
    <=
    assert // overflow
    frame_dig 0
    b|
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:144
    // assert arr.length == 7
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:145
    // assert arr[-1] == 2**512 - 2
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    pushbytes 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:146
    // assert arr[0] == 0
    dig 1
    extract 2 64
    bytec_1 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:148
    // arr = arr.append(BigUInt(2**512 - 1))
    swap
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:149
    // assert arr.length == 8
    dup
    intc_0 // 0
    extract_uint16
    dup
    intc_3 // 8
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:150
    // assert arr[-1] == 2**512 - 1
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:151
    // assert arr[0] == 0
    dup
    extract 2 64
    bytec_1 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:153
    // Box(ImmutableArray[BigUInt], key=b"biguint").value = arr
    bytec 7 // 0x62696775696e74
    box_del
    pop
    bytec 7 // 0x62696775696e74
    swap
    box_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array(length: uint64) -> void:
test_bool_array:
    // tests/artifacts/Arrays/immutable.py:155-156
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> None:
    proto 1 0
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:157
    // arr = ImmutableArray[bool]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:160
    // for i in urange(length):
    intc_0 // 0

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:160
    // for i in urange(length):
    frame_dig 2
    frame_dig -1
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:161
    // arr = arr.append(i == Txn.num_app_args)
    txn NumAppArgs
    frame_dig 2
    dup
    uncover 2
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 1
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:160
    // for i in urange(length):
    intc_1 // 1
    +
    frame_bury 2
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:163
    // assert arr.length == length
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:165
    // if length > 0:
    frame_dig -1
    bz test_bool_array_after_if_else@6
    // tests/artifacts/Arrays/immutable.py:166
    // assert not arr[0], "expected element 0 to be False"
    frame_dig 0
    assert // index access is out of bounds
    frame_dig 1
    pushint 16 // 16
    getbit
    !
    assert // expected element 0 to be False

test_bool_array_after_if_else@6:
    // tests/artifacts/Arrays/immutable.py:167
    // if length > 1:
    frame_dig -1
    intc_1 // 1
    >
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:168
    // assert not arr[1], "expected element 1 to be False"
    intc_1 // 1
    frame_dig 0
    <
    assert // index access is out of bounds
    frame_dig 1
    pushint 17 // 17
    getbit
    !
    assert // expected element 1 to be False

test_bool_array_after_if_else@8:
    // tests/artifacts/Arrays/immutable.py:169
    // if length > 2:
    frame_dig -1
    intc_2 // 2
    >
    bz test_bool_array_after_if_else@10
    // tests/artifacts/Arrays/immutable.py:170
    // assert arr[2], "expected element 2 to be True"
    intc_2 // 2
    frame_dig 0
    <
    assert // index access is out of bounds
    frame_dig 1
    pushint 18 // 18
    getbit
    assert // expected element 2 to be True

test_bool_array_after_if_else@10:
    // tests/artifacts/Arrays/immutable.py:171
    // if length > 3:
    frame_dig -1
    pushint 3 // 3
    >
    bz test_bool_array_after_if_else@12
    // tests/artifacts/Arrays/immutable.py:172
    // assert not arr[length - 1], "expected last element to be False"
    frame_dig -1
    intc_1 // 1
    -
    dup
    frame_dig 0
    <
    assert // index access is out of bounds
    pushint 16 // 16
    +
    frame_dig 1
    swap
    getbit
    !
    assert // expected last element to be False

test_bool_array_after_if_else@12:
    // tests/artifacts/Arrays/immutable.py:174
    // self.g = arr
    pushbytes "g"
    frame_dig 1
    app_global_put
    // tests/artifacts/Arrays/immutable.py:175
    // if length:
    frame_dig -1
    bz test_bool_array_after_if_else@14
    frame_dig 0
    intc_1 // 1
    -
    dup
    itob
    extract 6 0
    frame_dig 1
    swap
    replace2 0
    dig 1
    pushint 16 // 16
    +
    intc_0 // 0
    setbit
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    intc_2 // 2
    +
    intc_0 // 0
    swap
    substring3
    // tests/artifacts/Arrays/immutable.py:177
    // assert arr.length == length - 1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    intc_1 // 1
    -
    ==
    assert

test_bool_array_after_if_else@14:
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_tuple_array() -> void:
test_fixed_size_tuple_array:
    // tests/artifacts/Arrays/immutable.py:179-180
    // @arc4.abimethod()
    // def test_fixed_size_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:181
    // arr = ImmutableArray[tuple[UInt64, UInt64]]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:184
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:184
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:185
    // arr = arr.append((i + 1, i + 2))
    frame_dig 1
    dup
    intc_1 // 1
    +
    swap
    intc_2 // 2
    +
    dig 1
    itob
    swap
    itob
    concat
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    frame_bury 1
    b test_fixed_size_tuple_array_for_header@1

test_fixed_size_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:187
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:188
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:189
    // assert arr[-1] == (UInt64(5), UInt64(6))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 5 // 5
    ==
    swap
    pushint 6 // 6
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:191
    // arr = arr.pop()
    pushint 16 // 16
    callsub dynamic_array_pop_fixed_size
    bury 1
    // tests/artifacts/Arrays/immutable.py:192
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:193
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:194
    // assert arr[-1] == (UInt64(4), UInt64(5))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 4 // 4
    ==
    swap
    pushint 5 // 5
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:195
    // self.c = arr
    pushbytes "c"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_named_tuple_array() -> void:
test_fixed_size_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:197-198
    // @arc4.abimethod()
    // def test_fixed_size_named_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:199
    // arr = ImmutableArray[MyTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:202
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:202
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:203
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    *
    intc_2 // 2
    %
    !
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:202
    // for i in urange(5):
    intc_1 // 1
    +
    frame_bury 1
    b test_fixed_size_named_tuple_array_for_header@1

test_fixed_size_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:205
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:206
    // foo, bar, baz = arr[0]
    dup
    extract 2 9
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    // tests/artifacts/Arrays/immutable.py:207
    // assert foo == 0
    uncover 2
    !
    assert
    // tests/artifacts/Arrays/immutable.py:208
    // assert bar
    swap
    assert
    // tests/artifacts/Arrays/immutable.py:209
    // assert baz
    assert
    // tests/artifacts/Arrays/immutable.py:210
    // self.d = arr
    pushbytes "d"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_tuple_array() -> void:
test_dynamic_sized_tuple_array:
    // tests/artifacts/Arrays/immutable.py:212-213
    // @arc4.abimethod()
    // def test_dynamic_sized_tuple_array(self) -> None:
    proto 0 0
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:214
    // arr = ImmutableArray[tuple[UInt64, Bytes]]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:217
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:217
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:218
    // arr = arr.append((i + 1, op.bzero(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    bzero
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@1

test_dynamic_sized_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:220
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:221
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:221
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:222
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:223
    // assert arr[i][1].length == i, "expected 2nd element to be correct"
    len
    uncover 2
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@5

test_dynamic_sized_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:225
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:226
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:227
    // assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    intc_0 // 0
    bzero
    uncover 2
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:228
    // assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    pushint 3 // 3
    bzero
    uncover 2
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:229
    // self.e = arr
    pushbytes "e"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_named_tuple_array() -> void:
test_dynamic_sized_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:231-232
    // @arc4.abimethod()
    // def test_dynamic_sized_named_tuple_array(self) -> None:
    proto 0 0
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:233
    // arr = ImmutableArray[MyDynamicSizedTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:236
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:236
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:237
    // arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    callsub times
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@1

test_dynamic_sized_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:239
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:240
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_named_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:240
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:241
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:242
    // assert arr[i][1] == times(i), "expected 2nd element to be correct"
    uncover 2
    callsub times
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@5

test_dynamic_sized_named_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:244
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:245
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:246
    // assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    swap
    bytec_1 // ""
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:247
    // assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    swap
    pushbytes "   "
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:248
    // self.f = arr
    pushbytes "f"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_log(arr: bytes) -> void:
test_implicit_conversion_log:
    // tests/artifacts/Arrays/immutable.py:250-251
    // @arc4.abimethod()
    // def test_implicit_conversion_log(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:252
    // log(arr)
    frame_dig -1
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_emit(arr: bytes) -> void:
test_implicit_conversion_emit:
    // tests/artifacts/Arrays/immutable.py:254-255
    // @arc4.abimethod()
    // def test_implicit_conversion_emit(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:256
    // arc4.emit("emit_test", arr)
    pushbytes 0xfa40c0530002
    frame_dig -1
    concat
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_nested_array(arr_to_add: uint64, arr: bytes) -> bytes:
test_nested_array:
    // tests/artifacts/Arrays/immutable.py:258-261
    // @arc4.abimethod()
    // def test_nested_array(
    //     self, arr_to_add: UInt64, arr: ImmutableArray[ImmutableArray[UInt64]]
    // ) -> ImmutableArray[UInt64]:
    proto 2 1
    intc_0 // 0
    dupn 2
    bytec_1 // ""
    dupn 5
    // tests/artifacts/Arrays/immutable.py:262-263
    // # add n new arrays
    // for i in urange(arr_to_add):
    intc_0 // 0

test_nested_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:262-263
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 9
    frame_dig -2
    <
    bz test_nested_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:264
    // extra_arr = ImmutableArray[UInt64]()
    bytec_2 // 0x0000
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:265
    // for j in urange(i):
    intc_0 // 0
    frame_bury 7

test_nested_array_for_header@3:
    // tests/artifacts/Arrays/immutable.py:265
    // for j in urange(i):
    frame_dig 7
    frame_dig 9
    <
    bz test_nested_array_after_for@6
    // tests/artifacts/Arrays/immutable.py:266
    // extra_arr = extra_arr.append(j)
    frame_dig 7
    dup
    itob
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:265
    // for j in urange(i):
    intc_1 // 1
    +
    frame_bury 7
    b test_nested_array_for_header@3

test_nested_array_after_for@6:
    // tests/artifacts/Arrays/immutable.py:267
    // arr = arr.append(extra_arr)
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    bytec 4 // 0x0002
    frame_dig 0
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury -1
    // tests/artifacts/Arrays/immutable.py:262-263
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 9
    intc_1 // 1
    +
    frame_bury 9
    b test_nested_array_for_header@1

test_nested_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:269-270
    // # sum inner arrays and return an array containing sums
    // totals = ImmutableArray[UInt64]()
    bytec_2 // 0x0000
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:271
    // for inner_arr in arr:
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 3
    intc_0 // 0
    frame_bury 5

test_nested_array_for_header@9:
    // tests/artifacts/Arrays/immutable.py:271
    // for inner_arr in arr:
    frame_dig 5
    frame_dig 3
    <
    bz test_nested_array_after_for@12
    frame_dig -1
    extract 2 0
    frame_dig 5
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dup2
    extract_uint16
    intc_3 // 8
    *
    intc_2 // 2
    +
    extract3
    dup
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:519
    // total = UInt64()
    intc_0 // 0
    frame_bury 8
    // tests/artifacts/Arrays/immutable.py:520
    // for i in arr:
    intc_0 // 0
    extract_uint16
    frame_bury 4
    intc_0 // 0
    frame_bury 6

test_nested_array_for_header@14:
    // tests/artifacts/Arrays/immutable.py:520
    // for i in arr:
    frame_dig 6
    frame_dig 4
    <
    bz test_nested_array_after_for@16
    frame_dig 1
    extract 2 0
    frame_dig 6
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:521
    // total += i
    frame_dig 8
    +
    frame_bury 8
    intc_1 // 1
    +
    frame_bury 6
    b test_nested_array_for_header@14

test_nested_array_after_for@16:
    // tests/artifacts/Arrays/immutable.py:272
    // totals = totals.append(sum_arr(inner_arr))
    frame_dig 8
    itob
    frame_dig 2
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 2
    frame_dig 5
    intc_1 // 1
    +
    frame_bury 5
    b test_nested_array_for_header@9

test_nested_array_after_for@12:
    // tests/artifacts/Arrays/immutable.py:274
    // return totals
    frame_dig 2
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bit_packed_tuples() -> void:
test_bit_packed_tuples:
    // tests/artifacts/Arrays/immutable.py:276-277
    // @arc4.abimethod()
    // def test_bit_packed_tuples(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:278
    // arr2 = ImmutableArray[TwoBoolTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:279-281
    // arr7 = ImmutableArray[SevenBoolTuple]()
    // arr8 = ImmutableArray[EightBoolTuple]()
    // arr9 = ImmutableArray[NineBoolTuple]()
    dupn 3
    // tests/artifacts/Arrays/immutable.py:287
    // for i in urange(5):
    intc_0 // 0

test_bit_packed_tuples_for_header@1:
    // tests/artifacts/Arrays/immutable.py:287
    // for i in urange(5):
    frame_dig 4
    pushint 5 // 5
    <
    bz test_bit_packed_tuples_after_for@4
    // tests/artifacts/Arrays/immutable.py:288
    // arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
    frame_dig 4
    dup
    !
    dig 1
    intc_1 // 1
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    intc_1 // 1
    uncover 2
    setbit
    frame_dig 0
    dup
    cover 2
    dig 1
    concat // on error: max array length exceeded
    uncover 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:295
    // c=i == 2,
    dig 1
    intc_2 // 2
    ==
    // tests/artifacts/Arrays/immutable.py:296
    // d=i == 3,
    dig 2
    pushint 3 // 3
    ==
    // tests/artifacts/Arrays/immutable.py:297
    // e=i == 4,
    dig 3
    pushint 4 // 4
    ==
    // tests/artifacts/Arrays/immutable.py:298
    // f=i == 5,
    dig 4
    pushint 5 // 5
    ==
    // tests/artifacts/Arrays/immutable.py:299
    // g=i == 6,
    dig 5
    pushint 6 // 6
    ==
    // tests/artifacts/Arrays/immutable.py:292
    // bar=i + 1,
    dig 6
    intc_1 // 1
    +
    // tests/artifacts/Arrays/immutable.py:289-301
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    dig 7
    itob
    uncover 7
    intc_2 // 2
    uncover 8
    setbit
    pushint 3 // 3
    uncover 7
    setbit
    pushint 4 // 4
    uncover 6
    setbit
    pushint 5 // 5
    uncover 5
    setbit
    pushint 6 // 6
    uncover 4
    setbit
    dup2
    concat
    dig 3
    itob
    swap
    dig 1
    concat
    frame_dig 1
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:313
    // h=i == 7,
    dig 4
    pushint 7 // 7
    ==
    // tests/artifacts/Arrays/immutable.py:302-315
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    uncover 2
    pushint 7 // 7
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    dig 2
    concat
    frame_dig 2
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:328
    // i=i == 8,
    uncover 3
    intc_3 // 8
    ==
    // tests/artifacts/Arrays/immutable.py:316-330
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat
    swap
    concat
    frame_dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 3
    frame_bury 4
    b test_bit_packed_tuples_for_header@1

test_bit_packed_tuples_after_for@4:
    // tests/artifacts/Arrays/immutable.py:332
    // assert arr2.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:333
    // assert arr7.length == 5
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:334
    // assert arr8.length == 5
    frame_dig 2
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:335
    // assert arr9.length == 5
    frame_dig 3
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:336
    // self.bool2 = arr2
    pushbytes "bool2"
    uncover 4
    app_global_put
    // tests/artifacts/Arrays/immutable.py:337
    // self.bool7 = arr7
    pushbytes "bool7"
    uncover 3
    app_global_put
    // tests/artifacts/Arrays/immutable.py:338
    // self.bool8 = arr8
    pushbytes "bool8"
    uncover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:339
    // self.bool9 = arr9
    pushbytes "bool9"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.sum_uints_and_lengths_and_trues(arr1: bytes, arr2: bytes, arr3: bytes, arr4: bytes) -> uint64, uint64, uint64, uint64:
sum_uints_and_lengths_and_trues:
    // tests/artifacts/Arrays/immutable.py:341-348
    // @arc4.abimethod()
    // def sum_uints_and_lengths_and_trues(
    //     self,
    //     arr1: ImmutableArray[UInt64],
    //     arr2: ImmutableArray[bool],
    //     arr3: ImmutableArray[MyTuple],
    //     arr4: ImmutableArray[MyDynamicSizedTuple],
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    bytec_1 // ""
    dupn 8
    // tests/artifacts/Arrays/immutable.py:349
    // sum1 = sum2 = sum3 = sum4 = UInt64()
    intc_0 // 0
    dupn 3
    // tests/artifacts/Arrays/immutable.py:350
    // for i in arr1:
    frame_dig -4
    intc_0 // 0
    extract_uint16
    intc_0 // 0

sum_uints_and_lengths_and_trues_for_header@1:
    // tests/artifacts/Arrays/immutable.py:350
    // for i in arr1:
    frame_dig 14
    frame_dig 13
    <
    bz sum_uints_and_lengths_and_trues_after_for@4
    frame_dig -4
    extract 2 0
    frame_dig 14
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:351
    // sum1 += i
    frame_dig 12
    +
    frame_bury 12
    intc_1 // 1
    +
    frame_bury 14
    b sum_uints_and_lengths_and_trues_for_header@1

sum_uints_and_lengths_and_trues_after_for@4:
    // tests/artifacts/Arrays/immutable.py:352
    // for b in arr2:
    frame_dig -3
    intc_0 // 0
    extract_uint16
    frame_bury 0
    intc_0 // 0
    frame_bury 4

sum_uints_and_lengths_and_trues_for_header@5:
    // tests/artifacts/Arrays/immutable.py:352
    // for b in arr2:
    frame_dig 4
    frame_dig 0
    <
    bz sum_uints_and_lengths_and_trues_after_for@10
    frame_dig 4
    pushint 16 // 16
    +
    frame_dig -3
    swap
    getbit
    frame_dig 11
    frame_bury 6
    // tests/artifacts/Arrays/immutable.py:353
    // if b:
    bz sum_uints_and_lengths_and_trues_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:354
    // sum2 += 1
    frame_dig 11
    intc_1 // 1
    +
    frame_bury 6

sum_uints_and_lengths_and_trues_after_if_else@8:
    frame_dig 6
    frame_bury 11
    frame_dig 4
    intc_1 // 1
    +
    frame_bury 4
    b sum_uints_and_lengths_and_trues_for_header@5

sum_uints_and_lengths_and_trues_after_for@10:
    // tests/artifacts/Arrays/immutable.py:355
    // for tup in arr3:
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_bury 1
    intc_0 // 0
    frame_bury 5

sum_uints_and_lengths_and_trues_for_header@11:
    // tests/artifacts/Arrays/immutable.py:355
    // for tup in arr3:
    frame_dig 5
    frame_dig 1
    <
    bz sum_uints_and_lengths_and_trues_after_for@18
    frame_dig -2
    extract 2 0
    frame_dig 5
    pushint 9 // 9
    *
    pushint 9 // 9
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    frame_bury 8
    // tests/artifacts/Arrays/immutable.py:356
    // sum3 += tup.foo
    frame_dig 10
    uncover 2
    +
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:357
    // if tup.bar:
    bz sum_uints_and_lengths_and_trues_after_if_else@14
    // tests/artifacts/Arrays/immutable.py:358
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@14:
    frame_dig 7
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:359
    // if tup.baz:
    frame_dig 8
    bz sum_uints_and_lengths_and_trues_after_if_else@16
    // tests/artifacts/Arrays/immutable.py:360
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@16:
    frame_dig 7
    frame_bury 10
    frame_dig 5
    intc_1 // 1
    +
    frame_bury 5
    b sum_uints_and_lengths_and_trues_for_header@11

sum_uints_and_lengths_and_trues_after_for@18:
    // tests/artifacts/Arrays/immutable.py:361
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 2
    intc_0 // 0
    frame_bury 3

sum_uints_and_lengths_and_trues_for_header@19:
    // tests/artifacts/Arrays/immutable.py:361
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig 3
    frame_dig 2
    <
    bz sum_uints_and_lengths_and_trues_after_for@22
    frame_dig -1
    extract 2 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 2
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:362
    // sum4 += dyn_tup.foo
    frame_dig 9
    uncover 2
    +
    // tests/artifacts/Arrays/immutable.py:363
    // sum4 += dyn_tup.bar.bytes.length
    swap
    len
    swap
    dig 1
    +
    frame_bury 9
    // tests/artifacts/Arrays/immutable.py:364
    // assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
    uncover 2
    ==
    assert // expected string length to match index
    frame_bury 3
    b sum_uints_and_lengths_and_trues_for_header@19

sum_uints_and_lengths_and_trues_after_for@22:
    // tests/artifacts/Arrays/immutable.py:366
    // return sum1, sum2, sum3, sum4
    frame_dig 12
    frame_dig 11
    frame_dig 10
    frame_dig 9
    frame_bury 3
    frame_bury 2
    frame_bury 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_return(append: uint64) -> bytes:
test_uint64_return:
    // tests/artifacts/Arrays/immutable.py:368-369
    // @arc4.abimethod()
    // def test_uint64_return(self, append: UInt64) -> ImmutableArray[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:370
    // arr = ImmutableArray(UInt64(1), UInt64(2), UInt64(3))
    pushbytes 0x0003000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:371
    // for i in urange(append):
    intc_0 // 0

test_uint64_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:371
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_uint64_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:372
    // arr = arr.append(i)
    frame_dig 1
    dup
    itob
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:371
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_return_for_header@1

test_uint64_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:373
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_return(append: uint64) -> bytes:
test_bool_return:
    // tests/artifacts/Arrays/immutable.py:375-376
    // @arc4.abimethod()
    // def test_bool_return(self, append: UInt64) -> ImmutableArray[bool]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:377
    // arr = ImmutableArray(True, False, True, False, True)
    pushbytes 0x0005a8
    // tests/artifacts/Arrays/immutable.py:378
    // for i in urange(append):
    intc_0 // 0

test_bool_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:378
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_bool_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:379
    // arr = arr.append(i % 2 == 0)
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 0
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:378
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_bool_return_for_header@1

test_bool_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:380
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_tuple_return(append: uint64) -> bytes:
test_tuple_return:
    // tests/artifacts/Arrays/immutable.py:382-383
    // @arc4.abimethod()
    // def test_tuple_return(self, append: UInt64) -> ImmutableArray[MyTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:384
    // arr = ImmutableArray(MyTuple(UInt64(), True, False))
    pushbytes 0x0001000000000000000080
    // tests/artifacts/Arrays/immutable.py:385
    // for i in urange(append):
    intc_0 // 0

test_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:385
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:386
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:385
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_tuple_return_for_header@1

test_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:387
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_tuple_return(append: uint64) -> bytes:
test_dynamic_tuple_return:
    // tests/artifacts/Arrays/immutable.py:389-390
    // @arc4.abimethod()
    // def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:391
    // arr = ImmutableArray(MyDynamicSizedTuple(UInt64(), String("Hello")))
    pushbytes 0x000100020000000000000000000a000548656c6c6f
    // tests/artifacts/Arrays/immutable.py:392
    // for i in urange(append):
    intc_0 // 0

test_dynamic_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:392
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_dynamic_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:393
    // arr = arr.append(MyDynamicSizedTuple(i, times(i)))
    frame_dig 1
    dup
    callsub times
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:392
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_dynamic_tuple_return_for_header@1

test_dynamic_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:394
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_convert_to_array_and_back(arr: bytes, append: uint64) -> bytes:
test_convert_to_array_and_back:
    // tests/artifacts/Arrays/immutable.py:396-399
    // @arc4.abimethod()
    // def test_convert_to_array_and_back(
    //     self, arr: ImmutableArray[MyTuple], append: UInt64
    // ) -> ImmutableArray[MyTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:401
    // mutable.extend(arr)
    frame_dig -2
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:402
    // for i in urange(append):
    intc_0 // 0

test_convert_to_array_and_back_for_header@1:
    // tests/artifacts/Arrays/immutable.py:402
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_convert_to_array_and_back_after_for@4
    // tests/artifacts/Arrays/immutable.py:403
    // mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    frame_dig 0
    cover 3
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    uncover 2
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:402
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_convert_to_array_and_back_for_header@1

test_convert_to_array_and_back_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/immutable.py:404
    // return mutable.freeze()
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:406-409
    // @arc4.abimethod()
    // def test_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:410
    // prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
    bytec 8 // 0x000200000000000000010000000000000002
    // tests/artifacts/Arrays/immutable.py:411
    // result = prefix + arg
    frame_dig -1
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:412
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:414-417
    // @arc4.abimethod()
    // def test_concat_with_native_tuple(
    //     self, arg: tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:419
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/immutable.py:418
    // prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
    bytec 8 // 0x000200000000000000010000000000000002
    // tests/artifacts/Arrays/immutable.py:419
    // result = prefix + arg
    swap
    concat // on error: max array length exceeded
    pushbytes 0x0004
    replace2 0
    // tests/artifacts/Arrays/immutable.py:420
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_dynamic_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:422-425
    // @arc4.abimethod()
    // def test_dynamic_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:427
    // result = prefix + arg
    frame_dig -1
    len
    frame_dig -1
    pushint 4 // 4
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:426
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec 9 // 0x000200040007000161000162
    // tests/artifacts/Arrays/immutable.py:427
    // result = prefix + arg
    swap
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:428
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_dynamic_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:430-433
    // @arc4.abimethod()
    // def test_dynamic_concat_with_native_tuple(
    //     self, arg: tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:435
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/immutable.py:434
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec 9 // 0x000200040007000161000162
    // tests/artifacts/Arrays/immutable.py:435
    // result = prefix + arg
    swap
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:436
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_immutable_dynamic(imm1: bytes, imm2: bytes) -> bytes:
test_concat_immutable_dynamic:
    // tests/artifacts/Arrays/immutable.py:438-441
    // @arc4.abimethod()
    // def test_concat_immutable_dynamic(
    //     self, imm1: ImmutableArray[MyDynamicSizedTuple], imm2: ImmutableArray[MyDynamicSizedTuple]
    // ) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:442
    // return imm1 + imm2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_dig -2
    extract 2 0
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    callsub dynamic_array_concat_dynamic_element
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_immutable_arc4(imm: bytes) -> bytes:
test_immutable_arc4:
    // tests/artifacts/Arrays/immutable.py:444-445
    // @arc4.abimethod()
    // def test_immutable_arc4(self, imm: ImmutableArray[MyStruct]) -> ImmutableArray[MyStruct]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:446
    // assert imm, "expected non empty array"
    frame_dig -1
    intc_0 // 0
    extract_uint16
    dup
    assert // expected non empty array
    // tests/artifacts/Arrays/immutable.py:447
    // imm = imm.replace(imm.length - 1, imm[0])
    intc_1 // 1
    -
    frame_dig -1
    extract 2 16
    swap
    pushint 16 // 16
    *
    intc_2 // 2
    +
    frame_dig -1
    swap
    uncover 2
    replace3
    dup
    frame_bury -1
    // tests/artifacts/Arrays/immutable.py:448
    // return imm
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_imm_fixed_arr() -> bytes:
test_imm_fixed_arr:
    // tests/artifacts/Arrays/immutable.py:450-451
    // @arc4.abimethod()
    // def test_imm_fixed_arr(self) -> NativeStruct3:
    proto 0 1
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:452
    // arr1 = zero_bytes(NativeStruct3)
    pushint 48 // 48
    bzero
    dup
    // tests/artifacts/Arrays/immutable.py:453
    // struct12 = NativeStruct(Txn.num_app_args + 1, Txn.num_app_args + 2)
    txn NumAppArgs
    intc_1 // 1
    +
    txn NumAppArgs
    intc_2 // 2
    +
    swap
    itob
    swap
    itob
    concat
    dup
    cover 2
    // tests/artifacts/Arrays/immutable.py:454
    // arr2 = NativeStruct3((struct12, struct12, struct12))
    dup
    dig 1
    concat
    swap
    concat
    dup
    cover 2
    // tests/artifacts/Arrays/immutable.py:456
    // assert arr1 != arr2, "expected arrays to be different"
    !=
    assert // expected arrays to be different
    // tests/artifacts/Arrays/immutable.py:459
    // for i in urange(3):
    intc_0 // 0

test_imm_fixed_arr_for_header@1:
    // tests/artifacts/Arrays/immutable.py:459
    // for i in urange(3):
    frame_dig 4
    pushint 3 // 3
    <
    bz test_imm_fixed_arr_after_for@4
    // tests/artifacts/Arrays/immutable.py:460
    // arr1 = arr1.replace(i, struct12)
    frame_dig 4
    dup
    pushint 16 // 16
    *
    frame_dig 1
    swap
    frame_dig 2
    replace3
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:459
    // for i in urange(3):
    intc_1 // 1
    +
    frame_bury 4
    b test_imm_fixed_arr_for_header@1

test_imm_fixed_arr_after_for@4:
    // tests/artifacts/Arrays/immutable.py:462
    // assert arr1 == arr2, "expected arrays to be the same"
    frame_dig 1
    frame_dig 3
    ==
    assert // expected arrays to be the same
    intc_0 // 0
    frame_bury 0

test_imm_fixed_arr_for_header@5:
    // tests/artifacts/Arrays/immutable.py:464
    // for struct_it in arr1:
    frame_dig 0
    pushint 3 // 3
    <
    bz test_imm_fixed_arr_after_for@8
    frame_dig 0
    dup
    pushint 16 // 16
    *
    frame_dig 1
    swap
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:465
    // assert struct_it == struct12, "expected items on iteration to be the same"
    frame_dig 2
    ==
    assert // expected items on iteration to be the same
    intc_1 // 1
    +
    frame_bury 0
    b test_imm_fixed_arr_for_header@5

test_imm_fixed_arr_after_for@8:
    // tests/artifacts/Arrays/immutable.py:467
    // self.imm_fixed_arr = arr1
    bytec 10 // "imm_fixed_arr"
    frame_dig 1
    dup
    cover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:471
    // assert sum_imm_fixed(mut_arr.freeze()) == 15, "expected sum to be 15"
    dup
    callsub sum_imm_fixed
    pushint 15 // 15
    ==
    assert // expected sum to be 15
    // tests/artifacts/Arrays/immutable.py:473
    // mut_arr[0] = NativeStruct(UInt64(), UInt64())
    pushbytes 0x00000000000000000000000000000000
    replace2 0
    // tests/artifacts/Arrays/immutable.py:474
    // assert sum_imm_fixed(mut_arr.freeze()) == 10, "expected sum to be 10"
    callsub sum_imm_fixed
    pushint 10 // 10
    ==
    assert // expected sum to be 10
    // tests/artifacts/Arrays/immutable.py:476
    // return self.imm_fixed_arr
    intc_0 // 0
    bytec 10 // "imm_fixed_arr"
    app_global_get_ex
    assert // check self.imm_fixed_arr exists
    frame_bury 0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
-            "num_byte_slices": 10,
+            "num_byte_slices": 11,
             "num_uints": 0
         },
         "local": {
@@ -162,6 +177,10 @@
                 "g": {
                     "type": "bytes",
                     "key": "g"
+                },
+                "imm_fixed_arr": {
+                    "type": "bytes",
+                    "key": "imm_fixed_arr"
                 }
             },
             "reserved": {}
@@ -182,6 +201,14 @@
                     "type": "void"
                 }
             },
+            {
+                "name": "test_biguint_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
             {
                 "name": "test_bool_array",
                 "args": [
@@ -440,6 +467,27 @@
                 "returns": {
                     "type": "(uint64,string)[]"
                 }
+            },
+            {
+                "name": "test_immutable_arc4",
+                "args": [
+                    {
+                        "type": "(uint64,uint64)[]",
+                        "name": "imm"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64)[]"
+                }
+            },
+            {
+                "name": "test_imm_fixed_arr",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64)[3]"
+                }
             }
         ],
         "networks": {}
diff --git a/tests/artifacts/Arrays/data/ImmutableArrayContract.arc56.json b/tests/artifacts/Arrays/data/ImmutableArrayContract.arc56.json
index 70c5fb77..a88a4d3e 100644
--- a/tests/artifacts/Arrays/data/ImmutableArrayContract.arc56.json
+++ b/tests/artifacts/Arrays/data/ImmutableArrayContract.arc56.json
@@ -18,6 +18,22 @@
             "events": [],
             "recommendations": {}
         },
+        {
+            "name": "test_biguint_array",
+            "args": [],
+            "returns": {
+                "type": "void"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
+        },
         {
             "name": "test_bool_array",
             "args": [
@@ -446,6 +462,43 @@
             "readonly": false,
             "events": [],
             "recommendations": {}
+        },
+        {
+            "name": "test_immutable_arc4",
+            "args": [
+                {
+                    "type": "(uint64,uint64)[]",
+                    "name": "imm"
+                }
+            ],
+            "returns": {
+                "type": "(uint64,uint64)[]"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
+        },
+        {
+            "name": "test_imm_fixed_arr",
+            "args": [],
+            "returns": {
+                "type": "(uint64,uint64)[3]"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
         }
     ],
     "arcs": [
@@ -457,7 +510,7 @@
         "schema": {
             "global": {
                 "ints": 0,
-                "bytes": 10
+                "bytes": 11
             },
             "local": {
                 "ints": 0,
@@ -515,6 +568,11 @@
                     "keyType": "AVMString",
                     "valueType": "(uint64,bool,bool,bool,bool,bool,bool,bool,bool,bool,uint64)[]",
                     "key": "Ym9vbDk="
+                },
+                "imm_fixed_arr": {
+                    "keyType": "AVMString",
+                    "valueType": "(uint64,uint64)[3]",
+                    "key": "aW1tX2ZpeGVkX2Fycg=="
                 }
             },
             "local": {},
@@ -537,147 +595,223 @@
             "sourceInfo": [
                 {
                     "pc": [
-                        308,
-                        312,
-                        1436,
-                        1527,
-                        1555,
-                        1583,
-                        1616,
-                        1776,
-                        1840,
-                        2099,
-                        2180,
-                        2245,
-                        2410,
-                        2493,
-                        2556,
-                        3285,
-                        3406
-                    ],
-                    "errorMessage": "Index access is out of bounds"
-                },
-                {
-                    "pc": [
-                        216,
-                        238,
-                        281,
-                        300,
-                        327,
+                        330,
                         346,
-                        369,
-                        389,
-                        409,
-                        429,
+                        365,
+                        387,
+                        430,
                         449,
-                        499,
-                        511,
-                        534,
-                        549,
-                        564,
-                        576,
-                        588,
-                        600,
-                        612,
-                        628
+                        476,
+                        495,
+                        518,
+                        538,
+                        558,
+                        578,
+                        598,
+                        640,
+                        652,
+                        675,
+                        690,
+                        705,
+                        717,
+                        729,
+                        741,
+                        753,
+                        769,
+                        781
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        645
+                        798
                     ],
                     "errorMessage": "can only call when creating"
                 },
                 {
                     "pc": [
-                        219,
-                        241,
-                        284,
-                        303,
-                        330,
+                        333,
                         349,
-                        372,
-                        392,
-                        412,
-                        432,
+                        368,
+                        390,
+                        433,
                         452,
-                        502,
-                        514,
-                        537,
-                        552,
-                        567,
-                        579,
-                        591,
-                        603,
-                        615,
-                        631
+                        479,
+                        498,
+                        521,
+                        541,
+                        561,
+                        581,
+                        601,
+                        643,
+                        655,
+                        678,
+                        693,
+                        708,
+                        720,
+                        732,
+                        744,
+                        756,
+                        772,
+                        784
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        2228,
-                        2539
+                        4540
+                    ],
+                    "errorMessage": "check self.imm_fixed_arr exists"
+                },
+                {
+                    "pc": [
+                        2667,
+                        2980
                     ],
                     "errorMessage": "expected 1, 0"
                 },
                 {
                     "pc": [
-                        2140,
-                        2451
+                        2582,
+                        2895
                     ],
                     "errorMessage": "expected 1st element to be correct"
                 },
                 {
                     "pc": [
-                        2148,
-                        2461
+                        2587,
+                        2902
                     ],
                     "errorMessage": "expected 2nd element to be correct"
                 },
                 {
                     "pc": [
-                        2289,
-                        2601
+                        2728,
+                        3042
                     ],
                     "errorMessage": "expected 4, 3"
                 },
                 {
                     "pc": [
-                        1538
+                        4422
+                    ],
+                    "errorMessage": "expected arrays to be different"
+                },
+                {
+                    "pc": [
+                        4458
+                    ],
+                    "errorMessage": "expected arrays to be the same"
+                },
+                {
+                    "pc": [
+                        2023
                     ],
                     "errorMessage": "expected element 0 to be False"
                 },
                 {
                     "pc": [
-                        1566
+                        2042
                     ],
                     "errorMessage": "expected element 1 to be False"
                 },
                 {
                     "pc": [
-                        1593
+                        2060
                     ],
                     "errorMessage": "expected element 2 to be True"
                 },
                 {
                     "pc": [
-                        1627
+                        4485
+                    ],
+                    "errorMessage": "expected items on iteration to be the same"
+                },
+                {
+                    "pc": [
+                        2086
                     ],
                     "errorMessage": "expected last element to be False"
                 },
                 {
                     "pc": [
-                        3462
+                        4364
+                    ],
+                    "errorMessage": "expected non empty array"
+                },
+                {
+                    "pc": [
+                        3870
                     ],
                     "errorMessage": "expected string length to match index"
                 },
                 {
                     "pc": [
-                        3834
+                        4535
+                    ],
+                    "errorMessage": "expected sum to be 10"
+                },
+                {
+                    "pc": [
+                        4508
+                    ],
+                    "errorMessage": "expected sum to be 15"
+                },
+                {
+                    "pc": [
+                        1320,
+                        1696,
+                        1766,
+                        1823,
+                        1933,
+                        2016,
+                        2035,
+                        2054,
+                        2077,
+                        2232,
+                        2296,
+                        2538,
+                        2619,
+                        2684,
+                        2851,
+                        2934,
+                        2997,
+                        3707,
+                        3814,
+                        4481
+                    ],
+                    "errorMessage": "index access is out of bounds"
+                },
+                {
+                    "pc": [
+                        1391,
+                        1467,
+                        1593,
+                        1669,
+                        1721,
+                        1791,
+                        1903,
+                        2171,
+                        2364,
+                        3113,
+                        3261,
+                        3328,
+                        3414,
+                        3453,
+                        3484,
+                        3942,
+                        4065,
+                        4227,
+                        4260,
+                        4286
                     ],
                     "errorMessage": "max array length exceeded"
+                },
+                {
+                    "pc": [
+                        1784
+                    ],
+                    "errorMessage": "overflow"
                 }
             ],
             "pcOffsetMethod": "none"
@@ -688,19 +822,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock 0x00 0x151f7c75 0x 0x0000 0x0002 0x80 0x000a 0x00000000000000010000000000000002 0x000161000162
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@26
    pushbytess 0x44d42f99 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f // method "test_uint64_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]"
    txna ApplicationArgs 0
    match main_test_uint64_array_route@3 main_test_bool_array_route@4 main_test_fixed_size_tuple_array_route@5 main_test_fixed_size_named_tuple_array_route@6 main_test_dynamic_sized_tuple_array_route@7 main_test_dynamic_sized_named_tuple_array_route@8 main_test_implicit_conversion_log_route@9 main_test_implicit_conversion_emit_route@10 main_test_nested_array_route@11 main_test_bit_packed_tuples_route@12 main_sum_uints_and_lengths_and_trues_route@13 main_test_uint64_return_route@14 main_test_bool_return_route@15 main_test_tuple_return_route@16 main_test_dynamic_tuple_return_route@17 main_test_convert_to_array_and_back_route@18 main_test_concat_with_arc4_tuple_route@19 main_test_concat_with_native_tuple_route@20 main_test_dynamic_concat_with_arc4_tuple_route@21 main_test_dynamic_concat_with_native_tuple_route@22 main_test_concat_immutable_dynamic_route@23

main_after_if_else@30:
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    intc_0 // 0
    return

main_test_concat_immutable_dynamic_route@23:
    // tests/artifacts/Arrays/immutable.py:394
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:394
    // @arc4.abimethod()
    callsub test_concat_immutable_dynamic
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_native_tuple_route@22:
    // tests/artifacts/Arrays/immutable.py:386
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    intc_2 // 2
    extract_uint16
    dig 2
    uncover 2
    dig 2
    substring3
    dig 2
    len
    uncover 3
    uncover 3
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:386
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_native_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_arc4_tuple_route@21:
    // tests/artifacts/Arrays/immutable.py:378
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:378
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_arc4_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_native_tuple_route@20:
    // tests/artifacts/Arrays/immutable.py:370
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 8 // on error: Index access is out of bounds
    swap
    extract 8 8 // on error: Index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:370
    // @arc4.abimethod()
    callsub test_concat_with_native_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_arc4_tuple_route@19:
    // tests/artifacts/Arrays/immutable.py:362
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:362
    // @arc4.abimethod()
    callsub test_concat_with_arc4_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_convert_to_array_and_back_route@18:
    // tests/artifacts/Arrays/immutable.py:352
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/Arrays/immutable.py:352
    // @arc4.abimethod()
    callsub test_convert_to_array_and_back
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_tuple_return_route@17:
    // tests/artifacts/Arrays/immutable.py:345
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:345
    // @arc4.abimethod()
    callsub test_dynamic_tuple_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_tuple_return_route@16:
    // tests/artifacts/Arrays/immutable.py:338
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:338
    // @arc4.abimethod()
    callsub test_tuple_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bool_return_route@15:
    // tests/artifacts/Arrays/immutable.py:331
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:331
    // @arc4.abimethod()
    callsub test_bool_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_uint64_return_route@14:
    // tests/artifacts/Arrays/immutable.py:324
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:324
    // @arc4.abimethod()
    callsub test_uint64_return
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_sum_uints_and_lengths_and_trues_route@13:
    // tests/artifacts/Arrays/immutable.py:297
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arrays/immutable.py:297
    // @arc4.abimethod()
    callsub sum_uints_and_lengths_and_trues
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    uncover 3
    concat
    uncover 2
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bit_packed_tuples_route@12:
    // tests/artifacts/Arrays/immutable.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_bit_packed_tuples
    intc_1 // 1
    return

main_test_nested_array_route@11:
    // tests/artifacts/Arrays/immutable.py:214
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:214
    // @arc4.abimethod()
    callsub test_nested_array
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_implicit_conversion_emit_route@10:
    // tests/artifacts/Arrays/immutable.py:210
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:210
    // @arc4.abimethod()
    callsub test_implicit_conversion_emit
    intc_1 // 1
    return

main_test_implicit_conversion_log_route@9:
    // tests/artifacts/Arrays/immutable.py:206
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:206
    // @arc4.abimethod()
    callsub test_implicit_conversion_log
    intc_1 // 1
    return

main_test_dynamic_sized_named_tuple_array_route@8:
    // tests/artifacts/Arrays/immutable.py:187
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_named_tuple_array
    intc_1 // 1
    return

main_test_dynamic_sized_tuple_array_route@7:
    // tests/artifacts/Arrays/immutable.py:168
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_named_tuple_array_route@6:
    // tests/artifacts/Arrays/immutable.py:153
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_named_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_tuple_array_route@5:
    // tests/artifacts/Arrays/immutable.py:135
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_tuple_array
    intc_1 // 1
    return

main_test_bool_array_route@4:
    // tests/artifacts/Arrays/immutable.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:111
    // @arc4.abimethod()
    callsub test_bool_array
    intc_1 // 1
    return

main_test_uint64_array_route@3:
    // tests/artifacts/Arrays/immutable.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_uint64_array
    intc_1 // 1
    return

main_bare_routing@26:
    // tests/artifacts/Arrays/immutable.py:74
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@30
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_pop_fixed_size(array: bytes, fixed_byte_size: uint64) -> bytes, bytes:
dynamic_array_pop_fixed_size:
    proto 2 2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    itob
    extract 6 0
    frame_dig -2
    swap
    replace2 0
    dup
    len
    frame_dig -1
    -
    dup2
    frame_dig -1
    extract3
    uncover 2
    intc_0 // 0
    uncover 3
    substring3
    retsub


// _puya_lib.arc4.dynamic_array_pop_dynamic_element(array: bytes) -> bytes, bytes:
dynamic_array_pop_dynamic_element:
    proto 1 2
    frame_dig -1
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dup
    intc_2 // 2
    *
    dup
    frame_dig -1
    extract 2 0
    dup
    cover 2
    dup
    uncover 2
    extract_uint16
    dup
    uncover 2
    dup
    len
    swap
    cover 2
    substring3
    bytec_2 // 0x
    intc_0 // 0

dynamic_array_pop_dynamic_element_for_header@1:
    frame_dig 6
    frame_dig 1
    <
    bz dynamic_array_pop_dynamic_element_after_for@4
    frame_dig 2
    frame_dig 6
    dup
    cover 2
    extract_uint16
    intc_2 // 2
    -
    itob
    extract 6 2
    frame_dig 5
    swap
    concat
    frame_bury 5
    intc_2 // 2
    +
    frame_bury 6
    b dynamic_array_pop_dynamic_element_for_header@1

dynamic_array_pop_dynamic_element_after_for@4:
    frame_dig 0
    itob
    extract 6 2
    frame_dig 5
    concat
    frame_dig 1
    intc_2 // 2
    +
    frame_dig 2
    swap
    frame_dig 3
    substring3
    concat
    frame_dig 4
    frame_bury 0
    frame_bury 1
    retsub


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_2 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    dup
    uncover 2
    uncover 3
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 7

dynamic_array_concat_bits_after_if_else@2:
    frame_dig 7
    frame_bury 4
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    pushint 16 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_byte_length_head(array: bytes, new_items_bytes: bytes, new_items_count: uint64) -> bytes:
dynamic_array_concat_byte_length_head:
    proto 3 1
    frame_dig -3
    intc_0 // 0
    extract_uint16
    dup
    frame_dig -1
    +
    swap
    intc_2 // 2
    *
    intc_2 // 2
    +
    dig 1
    itob
    extract 6 2
    cover 2
    frame_dig -3
    intc_2 // 2
    dig 2
    substring3
    frame_dig -1
    intc_2 // 2
    *
    bzero
    concat
    frame_dig -3
    len
    frame_dig -3
    uncover 3
    uncover 2
    substring3
    concat
    frame_dig -2
    concat
    swap
    intc_2 // 2
    *
    dup
    intc_0 // 0
    swap

dynamic_array_concat_byte_length_head_for_header@2:
    frame_dig 3
    frame_dig 2
    <
    bz dynamic_array_concat_byte_length_head_after_for@5
    frame_dig 4
    dup
    itob
    extract 6 2
    frame_dig 1
    frame_dig 3
    dup
    cover 4
    uncover 2
    replace3
    dup
    frame_bury 1
    dig 1
    extract_uint16
    intc_2 // 2
    +
    +
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 3
    b dynamic_array_concat_byte_length_head_for_header@2

dynamic_array_concat_byte_length_head_after_for@5:
    frame_dig 0
    frame_dig 1
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    bytec_2 // ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.times(n: uint64) -> bytes:
times:
    // tests/artifacts/Arrays/immutable.py:401-402
    // @subroutine
    // def times(n: UInt64) -> String:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:403
    // result = String()
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:404
    // for _i in urange(n):
    intc_0 // 0

times_for_header@1:
    // tests/artifacts/Arrays/immutable.py:404
    // for _i in urange(n):
    frame_dig 1
    frame_dig -1
    <
    bz times_after_for@4
    // tests/artifacts/Arrays/immutable.py:405
    // result += String(" ")
    frame_dig 0
    pushbytes " "
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:404
    // for _i in urange(n):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b times_for_header@1

times_after_for@4:
    // tests/artifacts/Arrays/immutable.py:406
    // return result
    retsub


// tests.artifacts.Arrays.immutable.add_x(arr: bytes, x: uint64) -> bytes:
add_x:
    // tests/artifacts/Arrays/immutable.py:409-410
    // @subroutine
    // def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:411
    // for i in urange(x):
    intc_0 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/immutable.py:411
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/immutable.py:412
    // arr = arr.append(i)
    frame_dig -2
    extract 2 0
    frame_dig 0
    dup
    cover 2
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury -2
    // tests/artifacts/Arrays/immutable.py:411
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    // tests/artifacts/Arrays/immutable.py:413
    // return arr
    frame_dig -2
    swap
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_array() -> void:
test_uint64_array:
    // tests/artifacts/Arrays/immutable.py:75-76
    // @arc4.abimethod()
    // def test_uint64_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:80
    // arr = arr.append(UInt64(42))
    pushbytes 0x0001000000000000002a
    // tests/artifacts/Arrays/immutable.py:84
    // arr = add_x(arr, UInt64(5))
    pushint 5 // 5
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:85
    // assert arr.length == 6
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:86
    // assert arr[-1] == 4
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    intc_3 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:88
    // arr = arr.append(UInt64(43))
    pushint 43 // 43
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    dupn 2
    // tests/artifacts/Arrays/immutable.py:89
    // assert arr.length == 7
    intc_0 // 0
    extract_uint16
    dup
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:90
    // assert arr[-1] == 43
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 43 // 43
    ==
    assert
    intc_2 // 2
    // tests/artifacts/Arrays/immutable.py:91
    // assert arr[0] == 42
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    intc_0 // 0

test_uint64_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    frame_dig 1
    // tests/artifacts/Arrays/immutable.py:93
    // arr = pop_x(arr, UInt64(3))
    pushint 3 // 3
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    <
    bz test_uint64_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:419
    // arr = arr.pop()
    frame_dig 0
    intc_3 // 8
    callsub dynamic_array_pop_fixed_size
    frame_bury 0
    pop
    // tests/artifacts/Arrays/immutable.py:418
    // for _i in urange(x):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_array_for_header@2

test_uint64_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:94
    // assert arr.length == 4
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:95
    // assert arr[-1] == 2
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    intc_2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:97
    // arr = add_x(arr, UInt64(10))
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:98
    // assert arr.length == 14
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:99
    // assert arr[-1] == 9
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    intc_3 // 8
    *
    dig 1
    swap
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:101
    // arr = arr.append(UInt64(44))
    pushint 44 // 44
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:102
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:103
    // assert arr[-1] == 44
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:105
    // arr = arr.replace(2, UInt64(23))
    pushint 23 // 23
    itob
    intc_2 // 2
    uncover 2
    <
    assert // Index access is out of bounds
    replace2 18
    // tests/artifacts/Arrays/immutable.py:106
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:107
    // assert arr[2] == 23
    dup
    pushint 18 // 18
    extract_uint64
    pushint 23 // 23
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:109
    // self.a = arr
    pushbytes "a"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array(length: uint64) -> void:
test_bool_array:
    // tests/artifacts/Arrays/immutable.py:111-112
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> None:
    proto 1 0
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:113
    // arr = ImmutableArray[bool]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:116
    // for i in urange(length):
    intc_0 // 0

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:116
    // for i in urange(length):
    frame_dig 2
    frame_dig -1
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:117
    // arr = arr.append(i == Txn.num_app_args)
    txn NumAppArgs
    frame_dig 2
    dup
    uncover 2
    ==
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 1
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:116
    // for i in urange(length):
    intc_1 // 1
    +
    frame_bury 2
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:119
    // assert arr.length == length
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:121
    // if length > 0:
    frame_dig -1
    bz test_bool_array_after_if_else@6
    // tests/artifacts/Arrays/immutable.py:122
    // assert not arr[0], "expected element 0 to be False"
    frame_dig 1
    extract 2 0
    frame_dig 0
    assert // Index access is out of bounds
    intc_0 // 0
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    !
    assert // expected element 0 to be False

test_bool_array_after_if_else@6:
    // tests/artifacts/Arrays/immutable.py:123
    // if length > 1:
    frame_dig -1
    intc_1 // 1
    >
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:124
    // assert not arr[1], "expected element 1 to be False"
    frame_dig 1
    extract 2 0
    intc_1 // 1
    frame_dig 0
    <
    assert // Index access is out of bounds
    intc_1 // 1
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    !
    assert // expected element 1 to be False

test_bool_array_after_if_else@8:
    // tests/artifacts/Arrays/immutable.py:125
    // if length > 2:
    frame_dig -1
    intc_2 // 2
    >
    bz test_bool_array_after_if_else@10
    // tests/artifacts/Arrays/immutable.py:126
    // assert arr[2], "expected element 2 to be True"
    frame_dig 1
    extract 2 0
    intc_2 // 2
    frame_dig 0
    <
    assert // Index access is out of bounds
    intc_2 // 2
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    assert // expected element 2 to be True

test_bool_array_after_if_else@10:
    // tests/artifacts/Arrays/immutable.py:127
    // if length > 3:
    frame_dig -1
    pushint 3 // 3
    >
    bz test_bool_array_after_if_else@12
    // tests/artifacts/Arrays/immutable.py:128
    // assert not arr[length - 1], "expected last element to be False"
    frame_dig -1
    intc_1 // 1
    -
    frame_dig 1
    extract 2 0
    dig 1
    frame_dig 0
    <
    assert // Index access is out of bounds
    swap
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    !
    assert // expected last element to be False

test_bool_array_after_if_else@12:
    // tests/artifacts/Arrays/immutable.py:130
    // self.g = arr
    pushbytes "g"
    frame_dig 1
    app_global_put
    // tests/artifacts/Arrays/immutable.py:131
    // if length:
    frame_dig -1
    bz test_bool_array_after_if_else@14
    frame_dig 0
    intc_1 // 1
    -
    dup
    itob
    extract 6 0
    frame_dig 1
    swap
    replace2 0
    dig 1
    pushint 16 // 16
    +
    intc_0 // 0
    setbit
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    intc_2 // 2
    +
    intc_0 // 0
    swap
    substring3
    // tests/artifacts/Arrays/immutable.py:133
    // assert arr.length == length - 1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    intc_1 // 1
    -
    ==
    assert

test_bool_array_after_if_else@14:
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_tuple_array() -> void:
test_fixed_size_tuple_array:
    // tests/artifacts/Arrays/immutable.py:135-136
    // @arc4.abimethod()
    // def test_fixed_size_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:137
    // arr = ImmutableArray[tuple[UInt64, UInt64]]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:140
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:140
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:141
    // arr = arr.append((i + 1, i + 2))
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    intc_1 // 1
    +
    swap
    intc_2 // 2
    +
    dig 1
    itob
    swap
    itob
    concat
    uncover 2
    swap
    concat
    dup
    len
    pushint 16 // 16
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    frame_bury 1
    b test_fixed_size_tuple_array_for_header@1

test_fixed_size_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:143
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:144
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:145
    // assert arr[-1] == (UInt64(5), UInt64(6))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: Index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 5 // 5
    ==
    swap
    pushint 6 // 6
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:147
    // arr = arr.pop()
    pushint 16 // 16
    callsub dynamic_array_pop_fixed_size
    bury 1
    // tests/artifacts/Arrays/immutable.py:148
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:149
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:150
    // assert arr[-1] == (UInt64(4), UInt64(5))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: Index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 4 // 4
    ==
    swap
    pushint 5 // 5
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:151
    // self.c = arr
    pushbytes "c"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_named_tuple_array() -> void:
test_fixed_size_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:153-154
    // @arc4.abimethod()
    // def test_fixed_size_named_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:155
    // arr = ImmutableArray[MyTuple]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:158
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:158
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:159
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    *
    intc_2 // 2
    %
    !
    dig 2
    itob
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 4
    select
    concat
    pushint 65 // 65
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:158
    // for i in urange(5):
    intc_1 // 1
    +
    frame_bury 1
    b test_fixed_size_named_tuple_array_for_header@1

test_fixed_size_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:161
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:162
    // foo, bar, baz = arr[0]
    dup
    extract 2 9
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    // tests/artifacts/Arrays/immutable.py:163
    // assert foo == 0
    uncover 2
    !
    assert
    // tests/artifacts/Arrays/immutable.py:164
    // assert bar
    swap
    assert
    // tests/artifacts/Arrays/immutable.py:165
    // assert baz
    assert
    // tests/artifacts/Arrays/immutable.py:166
    // self.d = arr
    pushbytes "d"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_tuple_array() -> void:
test_dynamic_sized_tuple_array:
    // tests/artifacts/Arrays/immutable.py:168-169
    // @arc4.abimethod()
    // def test_dynamic_sized_tuple_array(self) -> None:
    proto 0 0
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:170
    // arr = ImmutableArray[tuple[UInt64, Bytes]]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:173
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:173
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:174
    // arr = arr.append((i + 1, op.bzero(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    bzero
    dig 1
    itob
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@1

test_dynamic_sized_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:176
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:177
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:177
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:178
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: Index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:179
    // assert arr[i][1].length == i, "expected 2nd element to be correct"
    extract 2 0
    len
    uncover 2
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@5

test_dynamic_sized_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:181
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:182
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:183
    // assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    intc_0 // 0
    bzero
    uncover 2
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:184
    // assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: Index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    pushint 3 // 3
    bzero
    uncover 2
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:185
    // self.e = arr
    pushbytes "e"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_named_tuple_array() -> void:
test_dynamic_sized_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:187-188
    // @arc4.abimethod()
    // def test_dynamic_sized_named_tuple_array(self) -> None:
    proto 0 0
    bytec_2 // ""
    // tests/artifacts/Arrays/immutable.py:189
    // arr = ImmutableArray[MyDynamicSizedTuple]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:192
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:192
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:193
    // arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    callsub times
    dig 1
    itob
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@1

test_dynamic_sized_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:195
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:196
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_named_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:196
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:197
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: Index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:198
    // assert arr[i][1] == times(i), "expected 2nd element to be correct"
    extract 2 0
    uncover 2
    callsub times
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@5

test_dynamic_sized_named_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:200
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:201
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:202
    // assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    swap
    bytec_2 // ""
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:203
    // assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: Index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    swap
    pushbytes "   "
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:204
    // self.f = arr
    pushbytes "f"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_log(arr: bytes) -> void:
test_implicit_conversion_log:
    // tests/artifacts/Arrays/immutable.py:206-207
    // @arc4.abimethod()
    // def test_implicit_conversion_log(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:208
    // log(arr)
    frame_dig -1
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_emit(arr: bytes) -> void:
test_implicit_conversion_emit:
    // tests/artifacts/Arrays/immutable.py:210-211
    // @arc4.abimethod()
    // def test_implicit_conversion_emit(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:212
    // arc4.emit("emit_test", arr)
    bytec 4 // 0x0002
    frame_dig -1
    concat
    pushbytes 0xfa40c053 // method "emit_test(uint64[])"
    swap
    concat
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_nested_array(arr_to_add: uint64, arr: bytes) -> bytes:
test_nested_array:
    // tests/artifacts/Arrays/immutable.py:214-217
    // @arc4.abimethod()
    // def test_nested_array(
    //     self, arr_to_add: UInt64, arr: ImmutableArray[ImmutableArray[UInt64]]
    // ) -> ImmutableArray[UInt64]:
    proto 2 1
    intc_0 // 0
    dupn 3
    bytec_2 // ""
    dupn 5
    // tests/artifacts/Arrays/immutable.py:218-219
    // # add n new arrays
    // for i in urange(arr_to_add):
    intc_0 // 0

test_nested_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:218-219
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 10
    frame_dig -2
    <
    bz test_nested_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:220
    // extra_arr = ImmutableArray[UInt64]()
    bytec_3 // 0x0000
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:221
    // for j in urange(i):
    intc_0 // 0
    frame_bury 8

test_nested_array_for_header@3:
    // tests/artifacts/Arrays/immutable.py:221
    // for j in urange(i):
    frame_dig 8
    frame_dig 10
    <
    bz test_nested_array_after_for@6
    // tests/artifacts/Arrays/immutable.py:222
    // extra_arr = extra_arr.append(j)
    frame_dig 1
    extract 2 0
    frame_dig 8
    dup
    cover 2
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:221
    // for j in urange(i):
    intc_1 // 1
    +
    frame_bury 8
    b test_nested_array_for_header@3

test_nested_array_after_for@6:
    // tests/artifacts/Arrays/immutable.py:223
    // arr = arr.append(extra_arr)
    bytec 4 // 0x0002
    frame_dig 1
    concat
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury -1
    // tests/artifacts/Arrays/immutable.py:218-219
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 10
    b test_nested_array_for_header@1

test_nested_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:225-226
    // # sum inner arrays and return an array containing sums
    // totals = ImmutableArray[UInt64]()
    bytec_3 // 0x0000
    frame_bury 3
    // tests/artifacts/Arrays/immutable.py:227
    // for inner_arr in arr:
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 4
    intc_0 // 0
    frame_bury 6

test_nested_array_for_header@9:
    // tests/artifacts/Arrays/immutable.py:227
    // for inner_arr in arr:
    frame_dig 6
    frame_dig 4
    <
    bz test_nested_array_after_for@12
    frame_dig -1
    extract 2 0
    frame_dig 6
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dup2
    extract_uint16
    intc_3 // 8
    *
    intc_2 // 2
    +
    extract3
    dup
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:228
    // totals = totals.append(sum_arr(inner_arr))
    frame_dig 3
    extract 2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:425
    // total = UInt64()
    intc_0 // 0
    frame_bury 9
    // tests/artifacts/Arrays/immutable.py:426
    // for i in arr:
    intc_0 // 0
    extract_uint16
    frame_bury 5
    intc_0 // 0
    frame_bury 7

test_nested_array_for_header@14:
    // tests/artifacts/Arrays/immutable.py:426
    // for i in arr:
    frame_dig 7
    frame_dig 5
    <
    bz test_nested_array_after_for@16
    frame_dig 2
    extract 2 0
    frame_dig 7
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:427
    // total += i
    frame_dig 9
    +
    frame_bury 9
    intc_1 // 1
    +
    frame_bury 7
    b test_nested_array_for_header@14

test_nested_array_after_for@16:
    // tests/artifacts/Arrays/immutable.py:428
    // return total
    frame_dig 9
    itob
    // tests/artifacts/Arrays/immutable.py:228
    // totals = totals.append(sum_arr(inner_arr))
    frame_dig 0
    swap
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 3
    frame_dig 6
    intc_1 // 1
    +
    frame_bury 6
    b test_nested_array_for_header@9

test_nested_array_after_for@12:
    // tests/artifacts/Arrays/immutable.py:230
    // return totals
    frame_dig 3
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bit_packed_tuples() -> void:
test_bit_packed_tuples:
    // tests/artifacts/Arrays/immutable.py:232-233
    // @arc4.abimethod()
    // def test_bit_packed_tuples(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:234
    // arr2 = ImmutableArray[TwoBoolTuple]()
    bytec_3 // 0x0000
    // tests/artifacts/Arrays/immutable.py:235-237
    // arr7 = ImmutableArray[SevenBoolTuple]()
    // arr8 = ImmutableArray[EightBoolTuple]()
    // arr9 = ImmutableArray[NineBoolTuple]()
    dupn 3
    // tests/artifacts/Arrays/immutable.py:243
    // for i in urange(5):
    intc_0 // 0

test_bit_packed_tuples_for_header@1:
    // tests/artifacts/Arrays/immutable.py:243
    // for i in urange(5):
    frame_dig 4
    pushint 5 // 5
    <
    bz test_bit_packed_tuples_after_for@4
    // tests/artifacts/Arrays/immutable.py:244
    // arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
    frame_dig 0
    extract 2 0
    frame_dig 4
    dup
    !
    dig 1
    intc_1 // 1
    ==
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 3
    select
    dup
    intc_1 // 1
    dig 3
    setbit
    uncover 4
    swap
    concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:245-257
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    frame_dig 1
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:251
    // c=i == 2,
    dig 3
    intc_2 // 2
    ==
    // tests/artifacts/Arrays/immutable.py:252
    // d=i == 3,
    dig 4
    pushint 3 // 3
    ==
    // tests/artifacts/Arrays/immutable.py:253
    // e=i == 4,
    dig 5
    pushint 4 // 4
    ==
    // tests/artifacts/Arrays/immutable.py:254
    // f=i == 5,
    dig 6
    pushint 5 // 5
    ==
    // tests/artifacts/Arrays/immutable.py:255
    // g=i == 6,
    dig 7
    pushint 6 // 6
    ==
    // tests/artifacts/Arrays/immutable.py:248
    // bar=i + 1,
    dig 8
    intc_1 // 1
    +
    // tests/artifacts/Arrays/immutable.py:247
    // foo=i,
    dig 9
    itob
    uncover 8
    concat
    pushint 65 // 65
    uncover 9
    setbit
    pushint 66 // 66
    uncover 7
    setbit
    pushint 67 // 67
    uncover 6
    setbit
    pushint 68 // 68
    uncover 5
    setbit
    pushint 69 // 69
    uncover 4
    setbit
    pushint 70 // 70
    uncover 3
    setbit
    dig 1
    itob
    dup2
    concat
    // tests/artifacts/Arrays/immutable.py:245-257
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    uncover 4
    swap
    concat
    dup
    len
    pushint 17 // 17
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:258-271
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    frame_dig 2
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:269
    // h=i == 7,
    dig 4
    pushint 7 // 7
    ==
    // tests/artifacts/Arrays/immutable.py:260
    // foo=i,
    uncover 3
    pushint 71 // 71
    uncover 2
    setbit
    dup
    dig 3
    concat
    // tests/artifacts/Arrays/immutable.py:258-271
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    uncover 2
    swap
    concat
    dup
    len
    pushint 17 // 17
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:272-286
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    frame_dig 3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:284
    // i=i == 8,
    uncover 4
    intc_3 // 8
    ==
    // tests/artifacts/Arrays/immutable.py:274
    // foo=i,
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    uncover 2
    swap
    concat
    uncover 2
    concat
    // tests/artifacts/Arrays/immutable.py:272-286
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    concat
    dup
    len
    pushint 18 // 18
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 3
    frame_bury 4
    b test_bit_packed_tuples_for_header@1

test_bit_packed_tuples_after_for@4:
    // tests/artifacts/Arrays/immutable.py:288
    // assert arr2.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:289
    // assert arr7.length == 5
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:290
    // assert arr8.length == 5
    frame_dig 2
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:291
    // assert arr9.length == 5
    frame_dig 3
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:292
    // self.bool2 = arr2
    pushbytes "bool2"
    uncover 4
    app_global_put
    // tests/artifacts/Arrays/immutable.py:293
    // self.bool7 = arr7
    pushbytes "bool7"
    uncover 3
    app_global_put
    // tests/artifacts/Arrays/immutable.py:294
    // self.bool8 = arr8
    pushbytes "bool8"
    uncover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:295
    // self.bool9 = arr9
    pushbytes "bool9"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.sum_uints_and_lengths_and_trues(arr1: bytes, arr2: bytes, arr3: bytes, arr4: bytes) -> uint64, uint64, uint64, uint64:
sum_uints_and_lengths_and_trues:
    // tests/artifacts/Arrays/immutable.py:297-304
    // @arc4.abimethod()
    // def sum_uints_and_lengths_and_trues(
    //     self,
    //     arr1: ImmutableArray[UInt64],
    //     arr2: ImmutableArray[bool],
    //     arr3: ImmutableArray[MyTuple],
    //     arr4: ImmutableArray[MyDynamicSizedTuple],
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    bytec_2 // ""
    dupn 8
    // tests/artifacts/Arrays/immutable.py:305
    // sum1 = sum2 = sum3 = sum4 = UInt64()
    intc_0 // 0
    dupn 3
    // tests/artifacts/Arrays/immutable.py:306
    // for i in arr1:
    frame_dig -4
    intc_0 // 0
    extract_uint16
    intc_0 // 0

sum_uints_and_lengths_and_trues_for_header@1:
    // tests/artifacts/Arrays/immutable.py:306
    // for i in arr1:
    frame_dig 14
    frame_dig 13
    <
    bz sum_uints_and_lengths_and_trues_after_for@4
    frame_dig -4
    extract 2 0
    frame_dig 14
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:307
    // sum1 += i
    frame_dig 12
    +
    frame_bury 12
    intc_1 // 1
    +
    frame_bury 14
    b sum_uints_and_lengths_and_trues_for_header@1

sum_uints_and_lengths_and_trues_after_for@4:
    // tests/artifacts/Arrays/immutable.py:308
    // for b in arr2:
    frame_dig -3
    intc_0 // 0
    extract_uint16
    frame_bury 0
    intc_0 // 0
    frame_bury 4

sum_uints_and_lengths_and_trues_for_header@5:
    // tests/artifacts/Arrays/immutable.py:308
    // for b in arr2:
    frame_dig 4
    frame_dig 0
    <
    bz sum_uints_and_lengths_and_trues_after_for@10
    frame_dig -3
    extract 2 0
    frame_dig 4
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    frame_dig 11
    frame_bury 6
    // tests/artifacts/Arrays/immutable.py:309
    // if b:
    bz sum_uints_and_lengths_and_trues_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:310
    // sum2 += 1
    frame_dig 11
    intc_1 // 1
    +
    frame_bury 6

sum_uints_and_lengths_and_trues_after_if_else@8:
    frame_dig 6
    frame_bury 11
    frame_dig 4
    intc_1 // 1
    +
    frame_bury 4
    b sum_uints_and_lengths_and_trues_for_header@5

sum_uints_and_lengths_and_trues_after_for@10:
    // tests/artifacts/Arrays/immutable.py:311
    // for tup in arr3:
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_bury 1
    intc_0 // 0
    frame_bury 5

sum_uints_and_lengths_and_trues_for_header@11:
    // tests/artifacts/Arrays/immutable.py:311
    // for tup in arr3:
    frame_dig 5
    frame_dig 1
    <
    bz sum_uints_and_lengths_and_trues_after_for@18
    frame_dig -2
    extract 2 0
    frame_dig 5
    pushint 9 // 9
    *
    pushint 9 // 9
    extract3 // on error: Index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    frame_bury 8
    // tests/artifacts/Arrays/immutable.py:312
    // sum3 += tup.foo
    frame_dig 10
    uncover 2
    +
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:313
    // if tup.bar:
    bz sum_uints_and_lengths_and_trues_after_if_else@14
    // tests/artifacts/Arrays/immutable.py:314
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@14:
    frame_dig 7
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:315
    // if tup.baz:
    frame_dig 8
    bz sum_uints_and_lengths_and_trues_after_if_else@16
    // tests/artifacts/Arrays/immutable.py:316
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@16:
    frame_dig 7
    frame_bury 10
    frame_dig 5
    intc_1 // 1
    +
    frame_bury 5
    b sum_uints_and_lengths_and_trues_for_header@11

sum_uints_and_lengths_and_trues_after_for@18:
    // tests/artifacts/Arrays/immutable.py:317
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 2
    intc_0 // 0
    frame_bury 3

sum_uints_and_lengths_and_trues_for_header@19:
    // tests/artifacts/Arrays/immutable.py:317
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig 3
    frame_dig 2
    <
    bz sum_uints_and_lengths_and_trues_after_for@22
    frame_dig -1
    extract 2 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 2
    dig 1
    - // on error: Index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:318
    // sum4 += dyn_tup.foo
    frame_dig 9
    uncover 2
    +
    // tests/artifacts/Arrays/immutable.py:319
    // sum4 += dyn_tup.bar.bytes.length
    swap
    len
    swap
    dig 1
    +
    frame_bury 9
    // tests/artifacts/Arrays/immutable.py:320
    // assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
    uncover 2
    ==
    assert // expected string length to match index
    frame_bury 3
    b sum_uints_and_lengths_and_trues_for_header@19

sum_uints_and_lengths_and_trues_after_for@22:
    // tests/artifacts/Arrays/immutable.py:322
    // return sum1, sum2, sum3, sum4
    frame_dig 12
    frame_dig 11
    frame_dig 10
    frame_dig 9
    frame_bury 3
    frame_bury 2
    frame_bury 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_return(append: uint64) -> bytes:
test_uint64_return:
    // tests/artifacts/Arrays/immutable.py:324-325
    // @arc4.abimethod()
    // def test_uint64_return(self, append: UInt64) -> ImmutableArray[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:326
    // arr = ImmutableArray(UInt64(1), UInt64(2), UInt64(3))
    pushbytes 0x0003000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:327
    // for i in urange(append):
    intc_0 // 0

test_uint64_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:327
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_uint64_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:328
    // arr = arr.append(i)
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    cover 2
    itob
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:327
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_return_for_header@1

test_uint64_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:329
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_return(append: uint64) -> bytes:
test_bool_return:
    // tests/artifacts/Arrays/immutable.py:331-332
    // @arc4.abimethod()
    // def test_bool_return(self, append: UInt64) -> ImmutableArray[bool]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:333
    // arr = ImmutableArray(True, False, True, False, True)
    bytec_3 // 0x0000
    pushbytes 0x8000800080
    pushint 5 // 5
    intc_3 // 8
    callsub dynamic_array_concat_bits
    // tests/artifacts/Arrays/immutable.py:334
    // for i in urange(append):
    intc_0 // 0

test_bool_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:334
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_bool_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:335
    // arr = arr.append(i % 2 == 0)
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    bytec_0 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 0
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:334
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_bool_return_for_header@1

test_bool_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:336
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_tuple_return(append: uint64) -> bytes:
test_tuple_return:
    // tests/artifacts/Arrays/immutable.py:338-339
    // @arc4.abimethod()
    // def test_tuple_return(self, append: UInt64) -> ImmutableArray[MyTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:340
    // arr = ImmutableArray(MyTuple(UInt64(), True, False))
    pushbytes 0x0001000000000000000080
    // tests/artifacts/Arrays/immutable.py:341
    // for i in urange(append):
    intc_0 // 0

test_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:341
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:342
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 0
    extract 2 0
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    dig 2
    itob
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 4
    select
    concat
    pushint 65 // 65
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:341
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_tuple_return_for_header@1

test_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:343
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_tuple_return(append: uint64) -> bytes:
test_dynamic_tuple_return:
    // tests/artifacts/Arrays/immutable.py:345-346
    // @arc4.abimethod()
    // def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:347
    // arr = ImmutableArray(MyDynamicSizedTuple(UInt64(), String("Hello")))
    intc_0 // 0
    bytec_2 // 0x
    intc_1 // 1
    pushbytes 0x00020000000000000000000a000548656c6c6f
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/Arrays/immutable.py:348
    // for i in urange(append):
    intc_0 // 0

test_dynamic_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:348
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_dynamic_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:349
    // arr = arr.append(MyDynamicSizedTuple(i, times(i)))
    frame_dig 1
    dup
    callsub times
    dig 1
    itob
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:348
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_dynamic_tuple_return_for_header@1

test_dynamic_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:350
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_convert_to_array_and_back(arr: bytes, append: uint64) -> bytes:
test_convert_to_array_and_back:
    // tests/artifacts/Arrays/immutable.py:352-355
    // @arc4.abimethod()
    // def test_convert_to_array_and_back(
    //     self, arr: ImmutableArray[MyTuple], append: UInt64
    // ) -> ImmutableArray[MyTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:357
    // mutable.extend(arr)
    frame_dig -2
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:358
    // for i in urange(append):
    intc_0 // 0

test_convert_to_array_and_back_for_header@1:
    // tests/artifacts/Arrays/immutable.py:358
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_convert_to_array_and_back_after_for@4
    // tests/artifacts/Arrays/immutable.py:359
    // mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    dig 2
    itob
    bytec_0 // 0x00
    bytec 5 // 0x80
    uncover 4
    select
    concat
    pushint 65 // 65
    uncover 2
    setbit
    frame_dig 0
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:358
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_convert_to_array_and_back_for_header@1

test_convert_to_array_and_back_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/immutable.py:360
    // return mutable.freeze()
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:362-365
    // @arc4.abimethod()
    // def test_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:367
    // result = prefix + arg
    bytec 7 // 0x00000000000000010000000000000002
    frame_dig -1
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:368
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:370-373
    // @arc4.abimethod()
    // def test_concat_with_native_tuple(
    //     self, arg: tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:375
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    bytec 7 // 0x00000000000000010000000000000002
    swap
    concat
    dup
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/immutable.py:376
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_dynamic_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:378-381
    // @arc4.abimethod()
    // def test_dynamic_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:382
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec_3 // 0x0000
    bytec 8 // 0x000161000162
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:383
    // result = prefix + arg
    frame_dig -1
    len
    frame_dig -1
    pushint 4 // 4
    uncover 2
    substring3
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:384
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_dynamic_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:386-389
    // @arc4.abimethod()
    // def test_dynamic_concat_with_native_tuple(
    //     self, arg: tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:390
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec_3 // 0x0000
    bytec 8 // 0x000161000162
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:391
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:392
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_immutable_dynamic(imm1: bytes, imm2: bytes) -> bytes:
test_concat_immutable_dynamic:
    // tests/artifacts/Arrays/immutable.py:394-397
    // @arc4.abimethod()
    // def test_concat_immutable_dynamic(
    //     self, imm1: ImmutableArray[MyDynamicSizedTuple], imm2: ImmutableArray[MyDynamicSizedTuple]
    // ) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:398
    // return imm1 + imm2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_dig -2
    extract 2 0
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    callsub dynamic_array_concat_dynamic_element
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock 0x151f7c75 0x 0x0000 0x00 0x0002 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0x000a 0x62696775696e74 0x000200000000000000010000000000000002 0x000200040007000161000162 "imm_fixed_arr"
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@29
    pushbytess 0x44d42f99 0xb7eaa60b 0x743d70ed 0x1c7e0494 0xa2d5860b 0xe05fc564 0x1e092b83 0x01310262 0xc8654a98 0x89d196f8 0x6cb7c991 0x9898bf02 0xf6b61ee8 0x60b86a7b 0x73ad283f 0x529dfae9 0x206d514f 0xe06465e2 0xec0300a2 0xecdf14af 0x511aca64 0x29852e4f 0x6d4aa358 0xb7cb96bd // method "test_uint64_array()void", method "test_biguint_array()void", method "test_bool_array(uint64)void", method "test_fixed_size_tuple_array()void", method "test_fixed_size_named_tuple_array()void", method "test_dynamic_sized_tuple_array()void", method "test_dynamic_sized_named_tuple_array()void", method "test_implicit_conversion_log(uint64[])void", method "test_implicit_conversion_emit(uint64[])void", method "test_nested_array(uint64,uint64[][])uint64[]", method "test_bit_packed_tuples()void", method "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)", method "test_uint64_return(uint64)uint64[]", method "test_bool_return(uint64)bool[]", method "test_tuple_return(uint64)(uint64,bool,bool)[]", method "test_dynamic_tuple_return(uint64)(uint64,string)[]", method "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]", method "test_concat_with_arc4_tuple((uint64,uint64))uint64[]", method "test_concat_with_native_tuple((uint64,uint64))uint64[]", method "test_dynamic_concat_with_arc4_tuple((string,string))string[]", method "test_dynamic_concat_with_native_tuple((string,string))string[]", method "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]", method "test_immutable_arc4((uint64,uint64)[])(uint64,uint64)[]", method "test_imm_fixed_arr()(uint64,uint64)[3]"
    txna ApplicationArgs 0
    match main_test_uint64_array_route@3 main_test_biguint_array_route@4 main_test_bool_array_route@5 main_test_fixed_size_tuple_array_route@6 main_test_fixed_size_named_tuple_array_route@7 main_test_dynamic_sized_tuple_array_route@8 main_test_dynamic_sized_named_tuple_array_route@9 main_test_implicit_conversion_log_route@10 main_test_implicit_conversion_emit_route@11 main_test_nested_array_route@12 main_test_bit_packed_tuples_route@13 main_sum_uints_and_lengths_and_trues_route@14 main_test_uint64_return_route@15 main_test_bool_return_route@16 main_test_tuple_return_route@17 main_test_dynamic_tuple_return_route@18 main_test_convert_to_array_and_back_route@19 main_test_concat_with_arc4_tuple_route@20 main_test_concat_with_native_tuple_route@21 main_test_dynamic_concat_with_arc4_tuple_route@22 main_test_dynamic_concat_with_native_tuple_route@23 main_test_concat_immutable_dynamic_route@24 main_test_immutable_arc4_route@25 main_test_imm_fixed_arr_route@26

main_after_if_else@33:
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    intc_0 // 0
    return

main_test_imm_fixed_arr_route@26:
    // tests/artifacts/Arrays/immutable.py:450
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_imm_fixed_arr
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_immutable_arc4_route@25:
    // tests/artifacts/Arrays/immutable.py:444
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:444
    // @arc4.abimethod()
    callsub test_immutable_arc4
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_immutable_dynamic_route@24:
    // tests/artifacts/Arrays/immutable.py:438
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:438
    // @arc4.abimethod()
    callsub test_concat_immutable_dynamic
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_native_tuple_route@23:
    // tests/artifacts/Arrays/immutable.py:430
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_0 // 0
    extract_uint16
    dig 1
    intc_2 // 2
    extract_uint16
    dig 2
    uncover 2
    dig 2
    substring3
    dig 2
    len
    uncover 3
    uncover 3
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:430
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_native_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_concat_with_arc4_tuple_route@22:
    // tests/artifacts/Arrays/immutable.py:422
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:422
    // @arc4.abimethod()
    callsub test_dynamic_concat_with_arc4_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_native_tuple_route@21:
    // tests/artifacts/Arrays/immutable.py:414
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 8
    swap
    extract 8 8
    // tests/artifacts/Arrays/immutable.py:414
    // @arc4.abimethod()
    callsub test_concat_with_native_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_concat_with_arc4_tuple_route@20:
    // tests/artifacts/Arrays/immutable.py:406
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:406
    // @arc4.abimethod()
    callsub test_concat_with_arc4_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_convert_to_array_and_back_route@19:
    // tests/artifacts/Arrays/immutable.py:396
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/Arrays/immutable.py:396
    // @arc4.abimethod()
    callsub test_convert_to_array_and_back
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_dynamic_tuple_return_route@18:
    // tests/artifacts/Arrays/immutable.py:389
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:389
    // @arc4.abimethod()
    callsub test_dynamic_tuple_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_tuple_return_route@17:
    // tests/artifacts/Arrays/immutable.py:382
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:382
    // @arc4.abimethod()
    callsub test_tuple_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bool_return_route@16:
    // tests/artifacts/Arrays/immutable.py:375
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:375
    // @arc4.abimethod()
    callsub test_bool_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_uint64_return_route@15:
    // tests/artifacts/Arrays/immutable.py:368
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:368
    // @arc4.abimethod()
    callsub test_uint64_return
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_sum_uints_and_lengths_and_trues_route@14:
    // tests/artifacts/Arrays/immutable.py:341
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arrays/immutable.py:341
    // @arc4.abimethod()
    callsub sum_uints_and_lengths_and_trues
    uncover 3
    itob
    uncover 3
    itob
    concat
    uncover 2
    itob
    concat
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bit_packed_tuples_route@13:
    // tests/artifacts/Arrays/immutable.py:276
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_bit_packed_tuples
    intc_1 // 1
    return

main_test_nested_array_route@12:
    // tests/artifacts/Arrays/immutable.py:258
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    // tests/artifacts/Arrays/immutable.py:258
    // @arc4.abimethod()
    callsub test_nested_array
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_implicit_conversion_emit_route@11:
    // tests/artifacts/Arrays/immutable.py:254
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:254
    // @arc4.abimethod()
    callsub test_implicit_conversion_emit
    intc_1 // 1
    return

main_test_implicit_conversion_log_route@10:
    // tests/artifacts/Arrays/immutable.py:250
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/immutable.py:250
    // @arc4.abimethod()
    callsub test_implicit_conversion_log
    intc_1 // 1
    return

main_test_dynamic_sized_named_tuple_array_route@9:
    // tests/artifacts/Arrays/immutable.py:231
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_named_tuple_array
    intc_1 // 1
    return

main_test_dynamic_sized_tuple_array_route@8:
    // tests/artifacts/Arrays/immutable.py:212
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_dynamic_sized_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_named_tuple_array_route@7:
    // tests/artifacts/Arrays/immutable.py:197
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_named_tuple_array
    intc_1 // 1
    return

main_test_fixed_size_tuple_array_route@6:
    // tests/artifacts/Arrays/immutable.py:179
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_fixed_size_tuple_array
    intc_1 // 1
    return

main_test_bool_array_route@5:
    // tests/artifacts/Arrays/immutable.py:155
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/immutable.py:155
    // @arc4.abimethod()
    callsub test_bool_array
    intc_1 // 1
    return

main_test_biguint_array_route@4:
    // tests/artifacts/Arrays/immutable.py:130
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_biguint_array
    intc_1 // 1
    return

main_test_uint64_array_route@3:
    // tests/artifacts/Arrays/immutable.py:94
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_uint64_array
    intc_1 // 1
    return

main_bare_routing@29:
    // tests/artifacts/Arrays/immutable.py:93
    // class ImmutableArrayContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@33
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_pop_fixed_size(array: bytes, fixed_byte_size: uint64) -> bytes, bytes:
dynamic_array_pop_fixed_size:
    proto 2 2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    itob
    extract 6 0
    frame_dig -2
    swap
    replace2 0
    dup
    len
    frame_dig -1
    -
    dup2
    frame_dig -1
    extract3
    uncover 2
    intc_0 // 0
    uncover 3
    substring3
    retsub


// _puya_lib.arc4.dynamic_array_pop_dynamic_element(array: bytes) -> bytes, bytes:
dynamic_array_pop_dynamic_element:
    proto 1 2
    frame_dig -1
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dup
    intc_2 // 2
    *
    dup
    frame_dig -1
    extract 2 0
    dup
    cover 2
    dup
    uncover 2
    extract_uint16
    dup
    uncover 2
    dup
    len
    swap
    cover 2
    substring3
    bytec_1 // 0x
    intc_0 // 0

dynamic_array_pop_dynamic_element_for_header@1:
    frame_dig 6
    frame_dig 1
    <
    bz dynamic_array_pop_dynamic_element_after_for@4
    frame_dig 2
    frame_dig 6
    dup
    cover 2
    extract_uint16
    intc_2 // 2
    -
    itob
    extract 6 2
    frame_dig 5
    swap
    concat
    frame_bury 5
    intc_2 // 2
    +
    frame_bury 6
    b dynamic_array_pop_dynamic_element_for_header@1

dynamic_array_pop_dynamic_element_after_for@4:
    frame_dig 0
    itob
    extract 6 2
    frame_dig 5
    concat
    frame_dig 1
    intc_2 // 2
    +
    frame_dig 2
    swap
    frame_dig 3
    substring3
    concat
    frame_dig 4
    frame_bury 0
    frame_bury 1
    retsub


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_1 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    dup
    uncover 2
    uncover 3
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    dup
    cover 3
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 7

dynamic_array_concat_bits_after_if_else@2:
    frame_dig 7
    frame_bury 4
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    pushint 16 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_byte_length_head(array: bytes, new_items_bytes: bytes, new_items_count: uint64) -> bytes:
dynamic_array_concat_byte_length_head:
    proto 3 1
    frame_dig -3
    intc_0 // 0
    extract_uint16
    dup
    frame_dig -1
    +
    swap
    intc_2 // 2
    *
    intc_2 // 2
    +
    dig 1
    itob
    extract 6 2
    cover 2
    frame_dig -3
    intc_2 // 2
    dig 2
    substring3
    frame_dig -1
    intc_2 // 2
    *
    bzero
    concat
    frame_dig -3
    len
    frame_dig -3
    uncover 3
    uncover 2
    substring3
    concat
    frame_dig -2
    concat
    swap
    intc_2 // 2
    *
    dup
    intc_0 // 0
    swap

dynamic_array_concat_byte_length_head_for_header@2:
    frame_dig 3
    frame_dig 2
    <
    bz dynamic_array_concat_byte_length_head_after_for@4
    frame_dig 4
    dup
    itob
    extract 6 2
    frame_dig 1
    frame_dig 3
    dup
    cover 4
    uncover 2
    replace3
    dup
    frame_bury 1
    dig 1
    extract_uint16
    intc_2 // 2
    +
    +
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 3
    b dynamic_array_concat_byte_length_head_for_header@2

dynamic_array_concat_byte_length_head_after_for@4:
    frame_dig 0
    frame_dig 1
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    bytec_1 // ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.sum_imm_fixed(arr: bytes) -> uint64:
sum_imm_fixed:
    // tests/artifacts/Arrays/immutable.py:479-480
    // @subroutine
    // def sum_imm_fixed(arr: NativeStruct3) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:481
    // total = UInt64(0)
    intc_0 // 0
    dup

sum_imm_fixed_for_header@1:
    // tests/artifacts/Arrays/immutable.py:482
    // for item in arr:
    frame_dig 1
    pushint 3 // 3
    <
    bz sum_imm_fixed_after_for@4
    // tests/artifacts/Arrays/immutable.py:482-483
    // for item in arr:
    //     total += item.foo
    frame_dig 1
    dup
    pushint 16 // 16
    *
    frame_dig -1
    swap
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:483
    // total += item.foo
    dup
    // tests/artifacts/Arrays/immutable.py:482-483
    // for item in arr:
    //     total += item.foo
    intc_0 // 0
    // tests/artifacts/Arrays/immutable.py:483
    // total += item.foo
    extract_uint64
    frame_dig 0
    +
    // tests/artifacts/Arrays/immutable.py:484
    // total += item.bar
    swap
    intc_3 // 8
    extract_uint64
    +
    frame_bury 0
    intc_1 // 1
    +
    frame_bury 1
    b sum_imm_fixed_for_header@1

sum_imm_fixed_after_for@4:
    // tests/artifacts/Arrays/immutable.py:485
    // return total
    retsub


// tests.artifacts.Arrays.immutable.times(n: uint64) -> bytes:
times:
    // tests/artifacts/Arrays/immutable.py:488-489
    // @subroutine
    // def times(n: UInt64) -> String:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:490
    // result = String()
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:491
    // for _i in urange(n):
    intc_0 // 0

times_for_header@1:
    // tests/artifacts/Arrays/immutable.py:491
    // for _i in urange(n):
    frame_dig 1
    frame_dig -1
    <
    bz times_after_for@4
    // tests/artifacts/Arrays/immutable.py:492
    // result += String(" ")
    frame_dig 0
    pushbytes " "
    concat
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:491
    // for _i in urange(n):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b times_for_header@1

times_after_for@4:
    // tests/artifacts/Arrays/immutable.py:493
    // return result
    retsub


// tests.artifacts.Arrays.immutable.add_x(arr: bytes, x: uint64) -> bytes:
add_x:
    // tests/artifacts/Arrays/immutable.py:496-497
    // @subroutine
    // def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:498
    // for i in urange(x):
    intc_0 // 0

add_x_for_header@1:
    // tests/artifacts/Arrays/immutable.py:498
    // for i in urange(x):
    frame_dig 0
    frame_dig -1
    <
    bz add_x_after_for@4
    // tests/artifacts/Arrays/immutable.py:499
    // arr = arr.append(i)
    frame_dig 0
    dup
    itob
    frame_dig -2
    swap
    concat // on error: max array length exceeded
    frame_dig -2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury -2
    // tests/artifacts/Arrays/immutable.py:498
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 0
    b add_x_for_header@1

add_x_after_for@4:
    // tests/artifacts/Arrays/immutable.py:500
    // return arr
    frame_dig -2
    swap
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_array() -> void:
test_uint64_array:
    // tests/artifacts/Arrays/immutable.py:94-95
    // @arc4.abimethod()
    // def test_uint64_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:99
    // arr = arr.append(UInt64(42))
    pushbytes 0x0001000000000000002a
    // tests/artifacts/Arrays/immutable.py:103
    // arr = add_x(arr, UInt64(5))
    pushint 5 // 5
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:104
    // assert arr.length == 6
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:105
    // assert arr[-1] == 4
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:107
    // arr = arr.append(UInt64(43))
    pushint 43 // 43
    itob
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    dupn 2
    // tests/artifacts/Arrays/immutable.py:108
    // assert arr.length == 7
    intc_0 // 0
    extract_uint16
    dup
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:109
    // assert arr[-1] == 43
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 43 // 43
    ==
    assert
    intc_2 // 2
    // tests/artifacts/Arrays/immutable.py:110
    // assert arr[0] == 42
    extract_uint64
    pushint 42 // 42
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    intc_0 // 0

test_uint64_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    frame_dig 1
    // tests/artifacts/Arrays/immutable.py:112
    // arr = pop_x(arr, UInt64(3))
    pushint 3 // 3
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    <
    bz test_uint64_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:506
    // arr = arr.pop()
    frame_dig 0
    intc_3 // 8
    callsub dynamic_array_pop_fixed_size
    frame_bury 0
    pop
    // tests/artifacts/Arrays/immutable.py:505
    // for _i in urange(x):
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_array_for_header@2

test_uint64_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:113
    // assert arr.length == 4
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:114
    // assert arr[-1] == 2
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    intc_2 // 2
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:116
    // arr = add_x(arr, UInt64(10))
    pushint 10 // 10
    callsub add_x
    // tests/artifacts/Arrays/immutable.py:117
    // assert arr.length == 14
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 14 // 14
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:118
    // assert arr[-1] == 9
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 9 // 9
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:120
    // arr = arr.append(UInt64(44))
    pushint 44 // 44
    itob
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:121
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:122
    // assert arr[-1] == 44
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 8
    *
    extract_uint64
    pushint 44 // 44
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:124
    // arr = arr.replace(2, UInt64(23))
    pushint 23 // 23
    itob
    replace2 18
    // tests/artifacts/Arrays/immutable.py:125
    // assert arr.length == 15
    dup
    intc_0 // 0
    extract_uint16
    pushint 15 // 15
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:126
    // assert arr[2] == 23
    dup
    pushint 18 // 18
    extract_uint64
    pushint 23 // 23
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:128
    // self.a = arr
    pushbytes "a"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_biguint_array() -> void:
test_biguint_array:
    // tests/artifacts/Arrays/immutable.py:130-131
    // @arc4.abimethod()
    // def test_biguint_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:135
    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
    txn NumAppArgs
    intc_1 // 1
    -
    itob
    pushint 64 // 64
    bzero
    dup
    cover 2
    b|
    // tests/artifacts/Arrays/immutable.py:132
    // arr = ImmutableArray[BigUInt]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:135
    // arr = arr.append(BigUInt(Txn.num_app_args - 1))
    swap
    concat // on error: max array length exceeded
    pushbytes 0x0001
    replace2 0
    dupn 2
    // tests/artifacts/Arrays/immutable.py:136
    // assert arr.length == 1
    intc_0 // 0
    extract_uint16
    dup
    intc_1 // 1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:137
    // assert arr[-1] == 0
    intc_1 // 1
    -
    swap
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    bytec_1 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    intc_0 // 0

test_biguint_array_for_header@2:
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    frame_dig 2
    // tests/artifacts/Arrays/immutable.py:139
    // arr = add_xb(arr, UInt64(5))
    pushint 5 // 5
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    <
    bz test_biguint_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:513
    // arr = arr.append(BigUInt(i))
    frame_dig 2
    dup
    itob
    frame_dig 0
    b|
    frame_dig 1
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:512
    // for i in urange(x):
    intc_1 // 1
    +
    frame_bury 2
    b test_biguint_array_for_header@2

test_biguint_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:140
    // assert arr.length == 6
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 6 // 6
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:141
    // assert arr[-1] == 4
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    pushbytes 0x04
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:143
    // arr = arr.append(BigUInt(2**512 - 1) - Txn.num_app_args)
    txn NumAppArgs
    itob
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    swap
    b-
    dup
    len
    pushint 64 // 64
    <=
    assert // overflow
    frame_dig 0
    b|
    uncover 2
    swap
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:144
    // assert arr.length == 7
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 7 // 7
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:145
    // assert arr[-1] == 2**512 - 2
    dup
    intc_1 // 1
    -
    dig 2
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    pushbytes 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:146
    // assert arr[0] == 0
    dig 1
    extract 2 64
    bytec_1 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:148
    // arr = arr.append(BigUInt(2**512 - 1))
    swap
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    concat // on error: max array length exceeded
    swap
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:149
    // assert arr.length == 8
    dup
    intc_0 // 0
    extract_uint16
    dup
    intc_3 // 8
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:150
    // assert arr[-1] == 2**512 - 1
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    pushint 64 // 64
    *
    pushint 64 // 64
    extract3 // on error: index access is out of bounds
    bytec 5 // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:151
    // assert arr[0] == 0
    dup
    extract 2 64
    bytec_1 // 0x
    b==
    assert
    // tests/artifacts/Arrays/immutable.py:153
    // Box(ImmutableArray[BigUInt], key=b"biguint").value = arr
    bytec 7 // 0x62696775696e74
    box_del
    pop
    bytec 7 // 0x62696775696e74
    swap
    box_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_array(length: uint64) -> void:
test_bool_array:
    // tests/artifacts/Arrays/immutable.py:155-156
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> None:
    proto 1 0
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:157
    // arr = ImmutableArray[bool]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:160
    // for i in urange(length):
    intc_0 // 0

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:160
    // for i in urange(length):
    frame_dig 2
    frame_dig -1
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:161
    // arr = arr.append(i == Txn.num_app_args)
    txn NumAppArgs
    frame_dig 2
    dup
    uncover 2
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 1
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:160
    // for i in urange(length):
    intc_1 // 1
    +
    frame_bury 2
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:163
    // assert arr.length == length
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:165
    // if length > 0:
    frame_dig -1
    bz test_bool_array_after_if_else@6
    // tests/artifacts/Arrays/immutable.py:166
    // assert not arr[0], "expected element 0 to be False"
    frame_dig 0
    assert // index access is out of bounds
    frame_dig 1
    pushint 16 // 16
    getbit
    !
    assert // expected element 0 to be False

test_bool_array_after_if_else@6:
    // tests/artifacts/Arrays/immutable.py:167
    // if length > 1:
    frame_dig -1
    intc_1 // 1
    >
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:168
    // assert not arr[1], "expected element 1 to be False"
    intc_1 // 1
    frame_dig 0
    <
    assert // index access is out of bounds
    frame_dig 1
    pushint 17 // 17
    getbit
    !
    assert // expected element 1 to be False

test_bool_array_after_if_else@8:
    // tests/artifacts/Arrays/immutable.py:169
    // if length > 2:
    frame_dig -1
    intc_2 // 2
    >
    bz test_bool_array_after_if_else@10
    // tests/artifacts/Arrays/immutable.py:170
    // assert arr[2], "expected element 2 to be True"
    intc_2 // 2
    frame_dig 0
    <
    assert // index access is out of bounds
    frame_dig 1
    pushint 18 // 18
    getbit
    assert // expected element 2 to be True

test_bool_array_after_if_else@10:
    // tests/artifacts/Arrays/immutable.py:171
    // if length > 3:
    frame_dig -1
    pushint 3 // 3
    >
    bz test_bool_array_after_if_else@12
    // tests/artifacts/Arrays/immutable.py:172
    // assert not arr[length - 1], "expected last element to be False"
    frame_dig -1
    intc_1 // 1
    -
    dup
    frame_dig 0
    <
    assert // index access is out of bounds
    pushint 16 // 16
    +
    frame_dig 1
    swap
    getbit
    !
    assert // expected last element to be False

test_bool_array_after_if_else@12:
    // tests/artifacts/Arrays/immutable.py:174
    // self.g = arr
    pushbytes "g"
    frame_dig 1
    app_global_put
    // tests/artifacts/Arrays/immutable.py:175
    // if length:
    frame_dig -1
    bz test_bool_array_after_if_else@14
    frame_dig 0
    intc_1 // 1
    -
    dup
    itob
    extract 6 0
    frame_dig 1
    swap
    replace2 0
    dig 1
    pushint 16 // 16
    +
    intc_0 // 0
    setbit
    swap
    pushint 7 // 7
    +
    intc_3 // 8
    /
    intc_2 // 2
    +
    intc_0 // 0
    swap
    substring3
    // tests/artifacts/Arrays/immutable.py:177
    // assert arr.length == length - 1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    intc_1 // 1
    -
    ==
    assert

test_bool_array_after_if_else@14:
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_tuple_array() -> void:
test_fixed_size_tuple_array:
    // tests/artifacts/Arrays/immutable.py:179-180
    // @arc4.abimethod()
    // def test_fixed_size_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:181
    // arr = ImmutableArray[tuple[UInt64, UInt64]]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:184
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:184
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:185
    // arr = arr.append((i + 1, i + 2))
    frame_dig 1
    dup
    intc_1 // 1
    +
    swap
    intc_2 // 2
    +
    dig 1
    itob
    swap
    itob
    concat
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    frame_bury 1
    b test_fixed_size_tuple_array_for_header@1

test_fixed_size_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:187
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:188
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:189
    // assert arr[-1] == (UInt64(5), UInt64(6))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 5 // 5
    ==
    swap
    pushint 6 // 6
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:191
    // arr = arr.pop()
    pushint 16 // 16
    callsub dynamic_array_pop_fixed_size
    bury 1
    // tests/artifacts/Arrays/immutable.py:192
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:193
    // assert arr[0] == (UInt64(1), UInt64(2))
    dig 1
    extract 2 0
    dig 2
    extract 2 16
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    intc_1 // 1
    ==
    swap
    intc_2 // 2
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:194
    // assert arr[-1] == (UInt64(4), UInt64(5))
    swap
    intc_1 // 1
    -
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    swap
    intc_3 // 8
    extract_uint64
    swap
    pushint 4 // 4
    ==
    swap
    pushint 5 // 5
    ==
    &&
    assert
    // tests/artifacts/Arrays/immutable.py:195
    // self.c = arr
    pushbytes "c"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_fixed_size_named_tuple_array() -> void:
test_fixed_size_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:197-198
    // @arc4.abimethod()
    // def test_fixed_size_named_tuple_array(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:199
    // arr = ImmutableArray[MyTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:202
    // for i in urange(5):
    intc_0 // 0

test_fixed_size_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:202
    // for i in urange(5):
    frame_dig 1
    pushint 5 // 5
    <
    bz test_fixed_size_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:203
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    *
    intc_2 // 2
    %
    !
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:202
    // for i in urange(5):
    intc_1 // 1
    +
    frame_bury 1
    b test_fixed_size_named_tuple_array_for_header@1

test_fixed_size_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:205
    // assert arr.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:206
    // foo, bar, baz = arr[0]
    dup
    extract 2 9
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    // tests/artifacts/Arrays/immutable.py:207
    // assert foo == 0
    uncover 2
    !
    assert
    // tests/artifacts/Arrays/immutable.py:208
    // assert bar
    swap
    assert
    // tests/artifacts/Arrays/immutable.py:209
    // assert baz
    assert
    // tests/artifacts/Arrays/immutable.py:210
    // self.d = arr
    pushbytes "d"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_tuple_array() -> void:
test_dynamic_sized_tuple_array:
    // tests/artifacts/Arrays/immutable.py:212-213
    // @arc4.abimethod()
    // def test_dynamic_sized_tuple_array(self) -> None:
    proto 0 0
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:214
    // arr = ImmutableArray[tuple[UInt64, Bytes]]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:217
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:217
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:218
    // arr = arr.append((i + 1, op.bzero(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    bzero
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@1

test_dynamic_sized_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:220
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:221
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:221
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:222
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:223
    // assert arr[i][1].length == i, "expected 2nd element to be correct"
    len
    uncover 2
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_tuple_array_for_header@5

test_dynamic_sized_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:225
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:226
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:227
    // assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    intc_0 // 0
    bzero
    uncover 2
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:228
    // assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    pushint 3 // 3
    bzero
    uncover 2
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:229
    // self.e = arr
    pushbytes "e"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_sized_named_tuple_array() -> void:
test_dynamic_sized_named_tuple_array:
    // tests/artifacts/Arrays/immutable.py:231-232
    // @arc4.abimethod()
    // def test_dynamic_sized_named_tuple_array(self) -> None:
    proto 0 0
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:233
    // arr = ImmutableArray[MyDynamicSizedTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:236
    // for i in urange(5):
    intc_0 // 0

test_dynamic_sized_named_tuple_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:236
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@4
    // tests/artifacts/Arrays/immutable.py:237
    // arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
    frame_dig 2
    dup
    intc_1 // 1
    +
    swap
    callsub times
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 1
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@1

test_dynamic_sized_named_tuple_array_after_for@4:
    // tests/artifacts/Arrays/immutable.py:239
    // assert arr.length == 5
    frame_dig 1
    intc_0 // 0
    extract_uint16
    dup
    frame_bury 0
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:240
    // for i in urange(5):
    intc_0 // 0
    frame_bury 2

test_dynamic_sized_named_tuple_array_for_header@5:
    // tests/artifacts/Arrays/immutable.py:240
    // for i in urange(5):
    frame_dig 2
    pushint 5 // 5
    <
    bz test_dynamic_sized_named_tuple_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:241
    // assert arr[i][0] == i + 1, "expected 1st element to be correct"
    frame_dig 1
    extract 2 0
    frame_dig 2
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 0
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    dig 2
    ==
    assert // expected 1st element to be correct
    // tests/artifacts/Arrays/immutable.py:242
    // assert arr[i][1] == times(i), "expected 2nd element to be correct"
    uncover 2
    callsub times
    ==
    assert // expected 2nd element to be correct
    frame_bury 2
    b test_dynamic_sized_named_tuple_array_for_header@5

test_dynamic_sized_named_tuple_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:244
    // arr = arr.pop()
    frame_dig 1
    callsub dynamic_array_pop_dynamic_element
    bury 1
    // tests/artifacts/Arrays/immutable.py:245
    // assert arr.length == 4
    dup
    intc_0 // 0
    extract_uint16
    dup
    pushint 4 // 4
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:246
    // assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
    dig 1
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    dig 1
    swap
    dig 3
    select
    dig 4
    uncover 4
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    intc_1 // 1
    ==
    swap
    bytec_1 // ""
    ==
    &&
    assert // expected 1, 0
    // tests/artifacts/Arrays/immutable.py:247
    // assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
    dig 1
    intc_2 // 2
    *
    dig 3
    swap
    extract_uint16
    uncover 2
    intc_1 // 1
    +
    uncover 4
    dig 1
    - // on error: index access is out of bounds
    swap
    intc_2 // 2
    *
    dig 4
    swap
    extract_uint16
    uncover 3
    swap
    uncover 2
    select
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    swap
    pushint 4 // 4
    ==
    swap
    pushbytes "   "
    ==
    &&
    assert // expected 4, 3
    // tests/artifacts/Arrays/immutable.py:248
    // self.f = arr
    pushbytes "f"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_log(arr: bytes) -> void:
test_implicit_conversion_log:
    // tests/artifacts/Arrays/immutable.py:250-251
    // @arc4.abimethod()
    // def test_implicit_conversion_log(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:252
    // log(arr)
    frame_dig -1
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_implicit_conversion_emit(arr: bytes) -> void:
test_implicit_conversion_emit:
    // tests/artifacts/Arrays/immutable.py:254-255
    // @arc4.abimethod()
    // def test_implicit_conversion_emit(self, arr: ImmutableArray[UInt64]) -> None:
    proto 1 0
    // tests/artifacts/Arrays/immutable.py:256
    // arc4.emit("emit_test", arr)
    pushbytes 0xfa40c0530002
    frame_dig -1
    concat
    log
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_nested_array(arr_to_add: uint64, arr: bytes) -> bytes:
test_nested_array:
    // tests/artifacts/Arrays/immutable.py:258-261
    // @arc4.abimethod()
    // def test_nested_array(
    //     self, arr_to_add: UInt64, arr: ImmutableArray[ImmutableArray[UInt64]]
    // ) -> ImmutableArray[UInt64]:
    proto 2 1
    intc_0 // 0
    dupn 2
    bytec_1 // ""
    dupn 5
    // tests/artifacts/Arrays/immutable.py:262-263
    // # add n new arrays
    // for i in urange(arr_to_add):
    intc_0 // 0

test_nested_array_for_header@1:
    // tests/artifacts/Arrays/immutable.py:262-263
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 9
    frame_dig -2
    <
    bz test_nested_array_after_for@8
    // tests/artifacts/Arrays/immutable.py:264
    // extra_arr = ImmutableArray[UInt64]()
    bytec_2 // 0x0000
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:265
    // for j in urange(i):
    intc_0 // 0
    frame_bury 7

test_nested_array_for_header@3:
    // tests/artifacts/Arrays/immutable.py:265
    // for j in urange(i):
    frame_dig 7
    frame_dig 9
    <
    bz test_nested_array_after_for@6
    // tests/artifacts/Arrays/immutable.py:266
    // extra_arr = extra_arr.append(j)
    frame_dig 7
    dup
    itob
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:265
    // for j in urange(i):
    intc_1 // 1
    +
    frame_bury 7
    b test_nested_array_for_header@3

test_nested_array_after_for@6:
    // tests/artifacts/Arrays/immutable.py:267
    // arr = arr.append(extra_arr)
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    bytec 4 // 0x0002
    frame_dig 0
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury -1
    // tests/artifacts/Arrays/immutable.py:262-263
    // # add n new arrays
    // for i in urange(arr_to_add):
    frame_dig 9
    intc_1 // 1
    +
    frame_bury 9
    b test_nested_array_for_header@1

test_nested_array_after_for@8:
    // tests/artifacts/Arrays/immutable.py:269-270
    // # sum inner arrays and return an array containing sums
    // totals = ImmutableArray[UInt64]()
    bytec_2 // 0x0000
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:271
    // for inner_arr in arr:
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 3
    intc_0 // 0
    frame_bury 5

test_nested_array_for_header@9:
    // tests/artifacts/Arrays/immutable.py:271
    // for inner_arr in arr:
    frame_dig 5
    frame_dig 3
    <
    bz test_nested_array_after_for@12
    frame_dig -1
    extract 2 0
    frame_dig 5
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dup2
    extract_uint16
    intc_3 // 8
    *
    intc_2 // 2
    +
    extract3
    dup
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:519
    // total = UInt64()
    intc_0 // 0
    frame_bury 8
    // tests/artifacts/Arrays/immutable.py:520
    // for i in arr:
    intc_0 // 0
    extract_uint16
    frame_bury 4
    intc_0 // 0
    frame_bury 6

test_nested_array_for_header@14:
    // tests/artifacts/Arrays/immutable.py:520
    // for i in arr:
    frame_dig 6
    frame_dig 4
    <
    bz test_nested_array_after_for@16
    frame_dig 1
    extract 2 0
    frame_dig 6
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:521
    // total += i
    frame_dig 8
    +
    frame_bury 8
    intc_1 // 1
    +
    frame_bury 6
    b test_nested_array_for_header@14

test_nested_array_after_for@16:
    // tests/artifacts/Arrays/immutable.py:272
    // totals = totals.append(sum_arr(inner_arr))
    frame_dig 8
    itob
    frame_dig 2
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 2
    frame_dig 5
    intc_1 // 1
    +
    frame_bury 5
    b test_nested_array_for_header@9

test_nested_array_after_for@12:
    // tests/artifacts/Arrays/immutable.py:274
    // return totals
    frame_dig 2
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bit_packed_tuples() -> void:
test_bit_packed_tuples:
    // tests/artifacts/Arrays/immutable.py:276-277
    // @arc4.abimethod()
    // def test_bit_packed_tuples(self) -> None:
    proto 0 0
    // tests/artifacts/Arrays/immutable.py:278
    // arr2 = ImmutableArray[TwoBoolTuple]()
    bytec_2 // 0x0000
    // tests/artifacts/Arrays/immutable.py:279-281
    // arr7 = ImmutableArray[SevenBoolTuple]()
    // arr8 = ImmutableArray[EightBoolTuple]()
    // arr9 = ImmutableArray[NineBoolTuple]()
    dupn 3
    // tests/artifacts/Arrays/immutable.py:287
    // for i in urange(5):
    intc_0 // 0

test_bit_packed_tuples_for_header@1:
    // tests/artifacts/Arrays/immutable.py:287
    // for i in urange(5):
    frame_dig 4
    pushint 5 // 5
    <
    bz test_bit_packed_tuples_after_for@4
    // tests/artifacts/Arrays/immutable.py:288
    // arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
    frame_dig 4
    dup
    !
    dig 1
    intc_1 // 1
    ==
    bytec_3 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    intc_1 // 1
    uncover 2
    setbit
    frame_dig 0
    dup
    cover 2
    dig 1
    concat // on error: max array length exceeded
    uncover 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:295
    // c=i == 2,
    dig 1
    intc_2 // 2
    ==
    // tests/artifacts/Arrays/immutable.py:296
    // d=i == 3,
    dig 2
    pushint 3 // 3
    ==
    // tests/artifacts/Arrays/immutable.py:297
    // e=i == 4,
    dig 3
    pushint 4 // 4
    ==
    // tests/artifacts/Arrays/immutable.py:298
    // f=i == 5,
    dig 4
    pushint 5 // 5
    ==
    // tests/artifacts/Arrays/immutable.py:299
    // g=i == 6,
    dig 5
    pushint 6 // 6
    ==
    // tests/artifacts/Arrays/immutable.py:292
    // bar=i + 1,
    dig 6
    intc_1 // 1
    +
    // tests/artifacts/Arrays/immutable.py:289-301
    // arr7 = arr7.append(
    //     SevenBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //     )
    // )
    dig 7
    itob
    uncover 7
    intc_2 // 2
    uncover 8
    setbit
    pushint 3 // 3
    uncover 7
    setbit
    pushint 4 // 4
    uncover 6
    setbit
    pushint 5 // 5
    uncover 5
    setbit
    pushint 6 // 6
    uncover 4
    setbit
    dup2
    concat
    dig 3
    itob
    swap
    dig 1
    concat
    frame_dig 1
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:313
    // h=i == 7,
    dig 4
    pushint 7 // 7
    ==
    // tests/artifacts/Arrays/immutable.py:302-315
    // arr8 = arr8.append(
    //     EightBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //     )
    // )
    uncover 2
    pushint 7 // 7
    uncover 2
    setbit
    uncover 2
    swap
    concat
    dup
    dig 2
    concat
    frame_dig 2
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 2
    // tests/artifacts/Arrays/immutable.py:328
    // i=i == 8,
    uncover 3
    intc_3 // 8
    ==
    // tests/artifacts/Arrays/immutable.py:316-330
    // arr9 = arr9.append(
    //     NineBoolTuple(
    //         foo=i,
    //         bar=i + 1,
    //         a=i == 0,
    //         b=i == 1,
    //         c=i == 2,
    //         d=i == 3,
    //         e=i == 4,
    //         f=i == 5,
    //         g=i == 6,
    //         h=i == 7,
    //         i=i == 8,
    //     )
    // )
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat
    swap
    concat
    frame_dig 3
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 3
    frame_bury 4
    b test_bit_packed_tuples_for_header@1

test_bit_packed_tuples_after_for@4:
    // tests/artifacts/Arrays/immutable.py:332
    // assert arr2.length == 5
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:333
    // assert arr7.length == 5
    frame_dig 1
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:334
    // assert arr8.length == 5
    frame_dig 2
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:335
    // assert arr9.length == 5
    frame_dig 3
    dup
    intc_0 // 0
    extract_uint16
    pushint 5 // 5
    ==
    assert
    // tests/artifacts/Arrays/immutable.py:336
    // self.bool2 = arr2
    pushbytes "bool2"
    uncover 4
    app_global_put
    // tests/artifacts/Arrays/immutable.py:337
    // self.bool7 = arr7
    pushbytes "bool7"
    uncover 3
    app_global_put
    // tests/artifacts/Arrays/immutable.py:338
    // self.bool8 = arr8
    pushbytes "bool8"
    uncover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:339
    // self.bool9 = arr9
    pushbytes "bool9"
    swap
    app_global_put
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.sum_uints_and_lengths_and_trues(arr1: bytes, arr2: bytes, arr3: bytes, arr4: bytes) -> uint64, uint64, uint64, uint64:
sum_uints_and_lengths_and_trues:
    // tests/artifacts/Arrays/immutable.py:341-348
    // @arc4.abimethod()
    // def sum_uints_and_lengths_and_trues(
    //     self,
    //     arr1: ImmutableArray[UInt64],
    //     arr2: ImmutableArray[bool],
    //     arr3: ImmutableArray[MyTuple],
    //     arr4: ImmutableArray[MyDynamicSizedTuple],
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    bytec_1 // ""
    dupn 8
    // tests/artifacts/Arrays/immutable.py:349
    // sum1 = sum2 = sum3 = sum4 = UInt64()
    intc_0 // 0
    dupn 3
    // tests/artifacts/Arrays/immutable.py:350
    // for i in arr1:
    frame_dig -4
    intc_0 // 0
    extract_uint16
    intc_0 // 0

sum_uints_and_lengths_and_trues_for_header@1:
    // tests/artifacts/Arrays/immutable.py:350
    // for i in arr1:
    frame_dig 14
    frame_dig 13
    <
    bz sum_uints_and_lengths_and_trues_after_for@4
    frame_dig -4
    extract 2 0
    frame_dig 14
    dup
    cover 2
    intc_3 // 8
    *
    extract_uint64
    // tests/artifacts/Arrays/immutable.py:351
    // sum1 += i
    frame_dig 12
    +
    frame_bury 12
    intc_1 // 1
    +
    frame_bury 14
    b sum_uints_and_lengths_and_trues_for_header@1

sum_uints_and_lengths_and_trues_after_for@4:
    // tests/artifacts/Arrays/immutable.py:352
    // for b in arr2:
    frame_dig -3
    intc_0 // 0
    extract_uint16
    frame_bury 0
    intc_0 // 0
    frame_bury 4

sum_uints_and_lengths_and_trues_for_header@5:
    // tests/artifacts/Arrays/immutable.py:352
    // for b in arr2:
    frame_dig 4
    frame_dig 0
    <
    bz sum_uints_and_lengths_and_trues_after_for@10
    frame_dig 4
    pushint 16 // 16
    +
    frame_dig -3
    swap
    getbit
    frame_dig 11
    frame_bury 6
    // tests/artifacts/Arrays/immutable.py:353
    // if b:
    bz sum_uints_and_lengths_and_trues_after_if_else@8
    // tests/artifacts/Arrays/immutable.py:354
    // sum2 += 1
    frame_dig 11
    intc_1 // 1
    +
    frame_bury 6

sum_uints_and_lengths_and_trues_after_if_else@8:
    frame_dig 6
    frame_bury 11
    frame_dig 4
    intc_1 // 1
    +
    frame_bury 4
    b sum_uints_and_lengths_and_trues_for_header@5

sum_uints_and_lengths_and_trues_after_for@10:
    // tests/artifacts/Arrays/immutable.py:355
    // for tup in arr3:
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_bury 1
    intc_0 // 0
    frame_bury 5

sum_uints_and_lengths_and_trues_for_header@11:
    // tests/artifacts/Arrays/immutable.py:355
    // for tup in arr3:
    frame_dig 5
    frame_dig 1
    <
    bz sum_uints_and_lengths_and_trues_after_for@18
    frame_dig -2
    extract 2 0
    frame_dig 5
    pushint 9 // 9
    *
    pushint 9 // 9
    extract3 // on error: index access is out of bounds
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 64 // 64
    getbit
    uncover 2
    pushint 65 // 65
    getbit
    frame_bury 8
    // tests/artifacts/Arrays/immutable.py:356
    // sum3 += tup.foo
    frame_dig 10
    uncover 2
    +
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:357
    // if tup.bar:
    bz sum_uints_and_lengths_and_trues_after_if_else@14
    // tests/artifacts/Arrays/immutable.py:358
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@14:
    frame_dig 7
    dup
    frame_bury 10
    frame_bury 7
    // tests/artifacts/Arrays/immutable.py:359
    // if tup.baz:
    frame_dig 8
    bz sum_uints_and_lengths_and_trues_after_if_else@16
    // tests/artifacts/Arrays/immutable.py:360
    // sum3 += 1
    frame_dig 10
    intc_1 // 1
    +
    frame_bury 7

sum_uints_and_lengths_and_trues_after_if_else@16:
    frame_dig 7
    frame_bury 10
    frame_dig 5
    intc_1 // 1
    +
    frame_bury 5
    b sum_uints_and_lengths_and_trues_for_header@11

sum_uints_and_lengths_and_trues_after_for@18:
    // tests/artifacts/Arrays/immutable.py:361
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_bury 2
    intc_0 // 0
    frame_bury 3

sum_uints_and_lengths_and_trues_for_header@19:
    // tests/artifacts/Arrays/immutable.py:361
    // for idx, dyn_tup in uenumerate(arr4):
    frame_dig 3
    frame_dig 2
    <
    bz sum_uints_and_lengths_and_trues_after_for@22
    frame_dig -1
    extract 2 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    dig 2
    intc_1 // 1
    +
    frame_dig 2
    dig 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 2
    intc_2 // 2
    *
    dig 5
    swap
    extract_uint16
    uncover 2
    select
    uncover 3
    uncover 3
    uncover 2
    substring3
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    intc_3 // 8
    extract_uint16
    dig 2
    len
    uncover 3
    cover 2
    substring3
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:362
    // sum4 += dyn_tup.foo
    frame_dig 9
    uncover 2
    +
    // tests/artifacts/Arrays/immutable.py:363
    // sum4 += dyn_tup.bar.bytes.length
    swap
    len
    swap
    dig 1
    +
    frame_bury 9
    // tests/artifacts/Arrays/immutable.py:364
    // assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
    uncover 2
    ==
    assert // expected string length to match index
    frame_bury 3
    b sum_uints_and_lengths_and_trues_for_header@19

sum_uints_and_lengths_and_trues_after_for@22:
    // tests/artifacts/Arrays/immutable.py:366
    // return sum1, sum2, sum3, sum4
    frame_dig 12
    frame_dig 11
    frame_dig 10
    frame_dig 9
    frame_bury 3
    frame_bury 2
    frame_bury 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_uint64_return(append: uint64) -> bytes:
test_uint64_return:
    // tests/artifacts/Arrays/immutable.py:368-369
    // @arc4.abimethod()
    // def test_uint64_return(self, append: UInt64) -> ImmutableArray[UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:370
    // arr = ImmutableArray(UInt64(1), UInt64(2), UInt64(3))
    pushbytes 0x0003000000000000000100000000000000020000000000000003
    // tests/artifacts/Arrays/immutable.py:371
    // for i in urange(append):
    intc_0 // 0

test_uint64_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:371
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_uint64_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:372
    // arr = arr.append(i)
    frame_dig 1
    dup
    itob
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:371
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_uint64_return_for_header@1

test_uint64_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:373
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_bool_return(append: uint64) -> bytes:
test_bool_return:
    // tests/artifacts/Arrays/immutable.py:375-376
    // @arc4.abimethod()
    // def test_bool_return(self, append: UInt64) -> ImmutableArray[bool]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:377
    // arr = ImmutableArray(True, False, True, False, True)
    pushbytes 0x0005a8
    // tests/artifacts/Arrays/immutable.py:378
    // for i in urange(append):
    intc_0 // 0

test_bool_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:378
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_bool_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:379
    // arr = arr.append(i % 2 == 0)
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    bytec_3 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 0
    swap
    intc_1 // 1
    intc_3 // 8
    callsub dynamic_array_concat_bits
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:378
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_bool_return_for_header@1

test_bool_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:380
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_tuple_return(append: uint64) -> bytes:
test_tuple_return:
    // tests/artifacts/Arrays/immutable.py:382-383
    // @arc4.abimethod()
    // def test_tuple_return(self, append: UInt64) -> ImmutableArray[MyTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:384
    // arr = ImmutableArray(MyTuple(UInt64(), True, False))
    pushbytes 0x0001000000000000000080
    // tests/artifacts/Arrays/immutable.py:385
    // for i in urange(append):
    intc_0 // 0

test_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:385
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:386
    // arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    frame_dig 0
    dup
    uncover 2
    concat // on error: max array length exceeded
    swap
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    +
    itob
    extract 6 2
    replace2 0
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:385
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_tuple_return_for_header@1

test_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:387
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_tuple_return(append: uint64) -> bytes:
test_dynamic_tuple_return:
    // tests/artifacts/Arrays/immutable.py:389-390
    // @arc4.abimethod()
    // def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:391
    // arr = ImmutableArray(MyDynamicSizedTuple(UInt64(), String("Hello")))
    pushbytes 0x000100020000000000000000000a000548656c6c6f
    // tests/artifacts/Arrays/immutable.py:392
    // for i in urange(append):
    intc_0 // 0

test_dynamic_tuple_return_for_header@1:
    // tests/artifacts/Arrays/immutable.py:392
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_dynamic_tuple_return_after_for@4
    // tests/artifacts/Arrays/immutable.py:393
    // arr = arr.append(MyDynamicSizedTuple(i, times(i)))
    frame_dig 1
    dup
    callsub times
    frame_dig 0
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    dig 3
    itob
    dig 3
    len
    itob
    extract 6 2
    uncover 4
    concat
    swap
    bytec 6 // 0x000a
    concat
    swap
    concat
    bytec 4 // 0x0002
    swap
    concat
    cover 2
    intc_1 // 1
    uncover 3
    callsub dynamic_array_concat_dynamic_element
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:392
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_dynamic_tuple_return_for_header@1

test_dynamic_tuple_return_after_for@4:
    // tests/artifacts/Arrays/immutable.py:394
    // return arr
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_convert_to_array_and_back(arr: bytes, append: uint64) -> bytes:
test_convert_to_array_and_back:
    // tests/artifacts/Arrays/immutable.py:396-399
    // @arc4.abimethod()
    // def test_convert_to_array_and_back(
    //     self, arr: ImmutableArray[MyTuple], append: UInt64
    // ) -> ImmutableArray[MyTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:401
    // mutable.extend(arr)
    frame_dig -2
    extract 2 0
    // tests/artifacts/Arrays/immutable.py:402
    // for i in urange(append):
    intc_0 // 0

test_convert_to_array_and_back_for_header@1:
    // tests/artifacts/Arrays/immutable.py:402
    // for i in urange(append):
    frame_dig 1
    frame_dig -1
    <
    bz test_convert_to_array_and_back_after_for@4
    // tests/artifacts/Arrays/immutable.py:403
    // mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
    frame_dig 1
    dup
    intc_2 // 2
    %
    !
    dig 1
    pushint 3 // 3
    %
    !
    frame_dig 0
    cover 3
    dig 2
    itob
    bytec_3 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    intc_1 // 1
    uncover 3
    setbit
    concat
    uncover 2
    swap
    concat // on error: max array length exceeded
    frame_bury 0
    // tests/artifacts/Arrays/immutable.py:402
    // for i in urange(append):
    intc_1 // 1
    +
    frame_bury 1
    b test_convert_to_array_and_back_for_header@1

test_convert_to_array_and_back_after_for@4:
    frame_dig 0
    // tests/artifacts/Arrays/immutable.py:404
    // return mutable.freeze()
    dup
    len
    pushint 9 // 9
    /
    itob
    extract 6 2
    swap
    concat
    frame_bury 0
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:406-409
    // @arc4.abimethod()
    // def test_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:410
    // prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
    bytec 8 // 0x000200000000000000010000000000000002
    // tests/artifacts/Arrays/immutable.py:411
    // result = prefix + arg
    frame_dig -1
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_3 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/immutable.py:412
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:414-417
    // @arc4.abimethod()
    // def test_concat_with_native_tuple(
    //     self, arg: tuple[arc4.UInt64, arc4.UInt64]
    // ) -> ImmutableArray[arc4.UInt64]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:419
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/immutable.py:418
    // prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
    bytec 8 // 0x000200000000000000010000000000000002
    // tests/artifacts/Arrays/immutable.py:419
    // result = prefix + arg
    swap
    concat // on error: max array length exceeded
    pushbytes 0x0004
    replace2 0
    // tests/artifacts/Arrays/immutable.py:420
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_arc4_tuple(arg: bytes) -> bytes:
test_dynamic_concat_with_arc4_tuple:
    // tests/artifacts/Arrays/immutable.py:422-425
    // @arc4.abimethod()
    // def test_dynamic_concat_with_arc4_tuple(
    //     self, arg: arc4.Tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:427
    // result = prefix + arg
    frame_dig -1
    len
    frame_dig -1
    pushint 4 // 4
    uncover 2
    substring3
    // tests/artifacts/Arrays/immutable.py:426
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec 9 // 0x000200040007000161000162
    // tests/artifacts/Arrays/immutable.py:427
    // result = prefix + arg
    swap
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:428
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_dynamic_concat_with_native_tuple(arg.0: bytes, arg.1: bytes) -> bytes:
test_dynamic_concat_with_native_tuple:
    // tests/artifacts/Arrays/immutable.py:430-433
    // @arc4.abimethod()
    // def test_dynamic_concat_with_native_tuple(
    //     self, arg: tuple[arc4.String, arc4.String]
    // ) -> ImmutableArray[arc4.String]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:435
    // result = prefix + arg
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/immutable.py:434
    // prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
    bytec 9 // 0x000200040007000161000162
    // tests/artifacts/Arrays/immutable.py:435
    // result = prefix + arg
    swap
    intc_2 // 2
    callsub dynamic_array_concat_byte_length_head
    // tests/artifacts/Arrays/immutable.py:436
    // return result
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_concat_immutable_dynamic(imm1: bytes, imm2: bytes) -> bytes:
test_concat_immutable_dynamic:
    // tests/artifacts/Arrays/immutable.py:438-441
    // @arc4.abimethod()
    // def test_concat_immutable_dynamic(
    //     self, imm1: ImmutableArray[MyDynamicSizedTuple], imm2: ImmutableArray[MyDynamicSizedTuple]
    // ) -> ImmutableArray[MyDynamicSizedTuple]:
    proto 2 1
    // tests/artifacts/Arrays/immutable.py:442
    // return imm1 + imm2
    frame_dig -2
    intc_0 // 0
    extract_uint16
    frame_dig -2
    extract 2 0
    frame_dig -1
    intc_0 // 0
    extract_uint16
    frame_dig -1
    extract 2 0
    callsub dynamic_array_concat_dynamic_element
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_immutable_arc4(imm: bytes) -> bytes:
test_immutable_arc4:
    // tests/artifacts/Arrays/immutable.py:444-445
    // @arc4.abimethod()
    // def test_immutable_arc4(self, imm: ImmutableArray[MyStruct]) -> ImmutableArray[MyStruct]:
    proto 1 1
    // tests/artifacts/Arrays/immutable.py:446
    // assert imm, "expected non empty array"
    frame_dig -1
    intc_0 // 0
    extract_uint16
    dup
    assert // expected non empty array
    // tests/artifacts/Arrays/immutable.py:447
    // imm = imm.replace(imm.length - 1, imm[0])
    intc_1 // 1
    -
    frame_dig -1
    extract 2 16
    swap
    pushint 16 // 16
    *
    intc_2 // 2
    +
    frame_dig -1
    swap
    uncover 2
    replace3
    dup
    frame_bury -1
    // tests/artifacts/Arrays/immutable.py:448
    // return imm
    retsub


// tests.artifacts.Arrays.immutable.ImmutableArrayContract.test_imm_fixed_arr() -> bytes:
test_imm_fixed_arr:
    // tests/artifacts/Arrays/immutable.py:450-451
    // @arc4.abimethod()
    // def test_imm_fixed_arr(self) -> NativeStruct3:
    proto 0 1
    bytec_1 // ""
    // tests/artifacts/Arrays/immutable.py:452
    // arr1 = zero_bytes(NativeStruct3)
    pushint 48 // 48
    bzero
    dup
    // tests/artifacts/Arrays/immutable.py:453
    // struct12 = NativeStruct(Txn.num_app_args + 1, Txn.num_app_args + 2)
    txn NumAppArgs
    intc_1 // 1
    +
    txn NumAppArgs
    intc_2 // 2
    +
    swap
    itob
    swap
    itob
    concat
    dup
    cover 2
    // tests/artifacts/Arrays/immutable.py:454
    // arr2 = NativeStruct3((struct12, struct12, struct12))
    dup
    dig 1
    concat
    swap
    concat
    dup
    cover 2
    // tests/artifacts/Arrays/immutable.py:456
    // assert arr1 != arr2, "expected arrays to be different"
    !=
    assert // expected arrays to be different
    // tests/artifacts/Arrays/immutable.py:459
    // for i in urange(3):
    intc_0 // 0

test_imm_fixed_arr_for_header@1:
    // tests/artifacts/Arrays/immutable.py:459
    // for i in urange(3):
    frame_dig 4
    pushint 3 // 3
    <
    bz test_imm_fixed_arr_after_for@4
    // tests/artifacts/Arrays/immutable.py:460
    // arr1 = arr1.replace(i, struct12)
    frame_dig 4
    dup
    pushint 16 // 16
    *
    frame_dig 1
    swap
    frame_dig 2
    replace3
    frame_bury 1
    // tests/artifacts/Arrays/immutable.py:459
    // for i in urange(3):
    intc_1 // 1
    +
    frame_bury 4
    b test_imm_fixed_arr_for_header@1

test_imm_fixed_arr_after_for@4:
    // tests/artifacts/Arrays/immutable.py:462
    // assert arr1 == arr2, "expected arrays to be the same"
    frame_dig 1
    frame_dig 3
    ==
    assert // expected arrays to be the same
    intc_0 // 0
    frame_bury 0

test_imm_fixed_arr_for_header@5:
    // tests/artifacts/Arrays/immutable.py:464
    // for struct_it in arr1:
    frame_dig 0
    pushint 3 // 3
    <
    bz test_imm_fixed_arr_after_for@8
    frame_dig 0
    dup
    pushint 16 // 16
    *
    frame_dig 1
    swap
    pushint 16 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/immutable.py:465
    // assert struct_it == struct12, "expected items on iteration to be the same"
    frame_dig 2
    ==
    assert // expected items on iteration to be the same
    intc_1 // 1
    +
    frame_bury 0
    b test_imm_fixed_arr_for_header@5

test_imm_fixed_arr_after_for@8:
    // tests/artifacts/Arrays/immutable.py:467
    // self.imm_fixed_arr = arr1
    bytec 10 // "imm_fixed_arr"
    frame_dig 1
    dup
    cover 2
    app_global_put
    // tests/artifacts/Arrays/immutable.py:471
    // assert sum_imm_fixed(mut_arr.freeze()) == 15, "expected sum to be 15"
    dup
    callsub sum_imm_fixed
    pushint 15 // 15
    ==
    assert // expected sum to be 15
    // tests/artifacts/Arrays/immutable.py:473
    // mut_arr[0] = NativeStruct(UInt64(), UInt64())
    pushbytes 0x00000000000000000000000000000000
    replace2 0
    // tests/artifacts/Arrays/immutable.py:474
    // assert sum_imm_fixed(mut_arr.freeze()) == 10, "expected sum to be 10"
    callsub sum_imm_fixed
    pushint 10 // 10
    ==
    assert // expected sum to be 10
    // tests/artifacts/Arrays/immutable.py:476
    // return self.imm_fixed_arr
    intc_0 // 0
    bytec 10 // "imm_fixed_arr"
    app_global_get_ex
    assert // check self.imm_fixed_arr exists
    frame_bury 0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "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",
+        "approval": "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",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [
diff --git a/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal b/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal
index fe75c4c5..d19fda51 100644
--- a/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal
+++ b/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal
@@ -3,153 +3,169 @@
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.__algopy_entrypoint_with_init() -> uint64:
 main:
-    intcblock 1 0 8 80
-    bytecblock "count" 0x151f7c75 0x "a"
+    intcblock 0 1 8 16 144
+    bytecblock 0x151f7c75 "count" 0x00 0x 0x0000
     txn ApplicationID
     bnz main_after_if_else@2
-    // tests/artifacts/Arrays/static_size.py:26
+    // tests/artifacts/Arrays/static_size.py:39
     // self.count = UInt64(0)
-    bytec_0 // "count"
-    intc_1 // 0
+    bytec_1 // "count"
+    intc_0 // 0
     app_global_put
 
 main_after_if_else@2:
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@11
-    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64"
+    bz main_bare_routing@12
+    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 0x8d6e3a25 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64", method "test_arc4_bool()bool[]"
     txna ApplicationArgs 0
-    match main_test_array_route@5 main_test_extend_from_tuple_route@6 main_test_extend_from_arc4_tuple_route@7 main_test_bool_array_route@8 main_test_arc4_conversion_route@9 main_sum_array_route@10
+    match main_test_array_route@5 main_test_extend_from_tuple_route@6 main_test_extend_from_arc4_tuple_route@7 main_test_bool_array_route@8 main_test_arc4_conversion_route@9 main_sum_array_route@10 main_test_arc4_bool_route@11
 
-main_after_if_else@13:
-    // tests/artifacts/Arrays/static_size.py:24
+main_after_if_else@14:
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
-    intc_1 // 0
+    intc_0 // 0
+    return
+
+main_test_arc4_bool_route@11:
+    // tests/artifacts/Arrays/static_size.py:138
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub test_arc4_bool
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_1 // 1
     return
 
 main_sum_array_route@10:
-    // tests/artifacts/Arrays/static_size.py:94
+    // tests/artifacts/Arrays/static_size.py:112
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/Arrays/static_size.py:94
+    // tests/artifacts/Arrays/static_size.py:112
     // @arc4.abimethod()
     callsub sum_array
     itob
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    intc_0 // 1
+    intc_1 // 1
     return
 
 main_test_arc4_conversion_route@9:
-    // tests/artifacts/Arrays/static_size.py:76
+    // tests/artifacts/Arrays/static_size.py:94
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/static_size.py:76
+    // tests/artifacts/Arrays/static_size.py:94
     // @arc4.abimethod()
     callsub test_arc4_conversion
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    intc_0 // 1
+    intc_1 // 1
     return
 
 main_test_bool_array_route@8:
-    // tests/artifacts/Arrays/static_size.py:62
+    // tests/artifacts/Arrays/static_size.py:75
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/Arrays/static_size.py:62
+    // tests/artifacts/Arrays/static_size.py:75
     // @arc4.abimethod()
     callsub test_bool_array
     itob
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    intc_0 // 1
+    intc_1 // 1
     return
 
 main_test_extend_from_arc4_tuple_route@7:
-    // tests/artifacts/Arrays/static_size.py:54
+    // tests/artifacts/Arrays/static_size.py:67
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/Arrays/static_size.py:54
+    // tests/artifacts/Arrays/static_size.py:67
     // @arc4.abimethod()
     callsub test_extend_from_arc4_tuple
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    intc_0 // 1
+    intc_1 // 1
     return
 
 main_test_extend_from_tuple_route@6:
-    // tests/artifacts/Arrays/static_size.py:44
+    // tests/artifacts/Arrays/static_size.py:57
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     dup
-    extract 0 16 // on error: Index access is out of bounds
+    extract 0 16
     swap
-    extract 16 16 // on error: Index access is out of bounds
-    // tests/artifacts/Arrays/static_size.py:44
+    extract 16 16
+    // tests/artifacts/Arrays/static_size.py:57
     // @arc4.abimethod()
     callsub test_extend_from_tuple
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    intc_0 // 1
+    intc_1 // 1
     return
 
 main_test_array_route@5:
-    // tests/artifacts/Arrays/static_size.py:28
+    // tests/artifacts/Arrays/static_size.py:41
     // @arc4.abimethod()
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arrays/static_size.py:24
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
@@ -157,161 +173,271 @@ main_test_array_route@5:
     txna ApplicationArgs 3
     txna ApplicationArgs 4
     btoi
-    // tests/artifacts/Arrays/static_size.py:28
+    // tests/artifacts/Arrays/static_size.py:41
     // @arc4.abimethod()
     callsub test_array
     itob
-    bytec_1 // 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    intc_0 // 1
+    intc_1 // 1
     return
 
-main_bare_routing@11:
-    // tests/artifacts/Arrays/static_size.py:24
+main_bare_routing@12:
+    // tests/artifacts/Arrays/static_size.py:37
     // class StaticSizeContract(arc4.ARC4Contract):
     txn OnCompletion
-    bnz main_after_if_else@13
+    bnz main_after_if_else@14
     txn ApplicationID
     !
     assert // can only call when creating
-    intc_0 // 1
+    intc_1 // 1
     return
 
 
+// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
+dynamic_array_concat_bits:
+    proto 4 1
+    bytec_3 // ""
+    dupn 2
+    frame_dig -4
+    intc_0 // 0
+    extract_uint16
+    dupn 2
+    frame_dig -2
+    +
+    dup
+    itob
+    extract 6 0
+    frame_dig -4
+    swap
+    replace2 0
+    dup
+    uncover 2
+    uncover 3
+    pushint 7 // 7
+    +
+    intc_2 // 8
+    /
+    dup
+    cover 3
+    swap
+    pushint 7 // 7
+    +
+    intc_2 // 8
+    /
+    dup
+    cover 3
+    <
+    bz dynamic_array_concat_bits_after_if_else@2
+    frame_dig 6
+    frame_dig 5
+    -
+    bzero
+    frame_dig 4
+    swap
+    concat
+    frame_bury 7
+
+dynamic_array_concat_bits_after_if_else@2:
+    frame_dig 7
+    frame_bury 4
+    intc_0 // 0
+    frame_bury 0
+    frame_dig 3
+    intc_3 // 16
+    +
+    dup
+    frame_bury 2
+    frame_dig -2
+    +
+    frame_bury 1
+
+dynamic_array_concat_bits_while_top@3:
+    frame_dig 2
+    frame_dig 1
+    <
+    bz dynamic_array_concat_bits_after_while@5
+    frame_dig -3
+    frame_dig 0
+    dup
+    cover 2
+    getbit
+    frame_dig 4
+    frame_dig 2
+    dup
+    cover 3
+    uncover 2
+    setbit
+    frame_bury 4
+    intc_1 // 1
+    +
+    frame_bury 2
+    frame_dig -1
+    +
+    frame_bury 0
+    b dynamic_array_concat_bits_while_top@3
+
+dynamic_array_concat_bits_after_while@5:
+    frame_dig 4
+    frame_bury 0
+    retsub
+
+
 // tests.artifacts.Arrays.static_size.StaticSizeContract.test_array(x1: bytes, y1: uint64, x2: bytes, y2: uint64) -> uint64:
 test_array:
-    // tests/artifacts/Arrays/static_size.py:28-29
+    // tests/artifacts/Arrays/static_size.py:41-42
     // @arc4.abimethod()
     // def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
     proto 4 1
-    intc_1 // 0
+    intc_0 // 0
     dup
-    bytec_2 // ""
+    bytec_3 // ""
     dupn 5
-    // tests/artifacts/Arrays/static_size.py:30
+    // tests/artifacts/Arrays/static_size.py:43
     // self.count = UInt64(0)
-    bytec_0 // "count"
-    intc_1 // 0
+    bytec_1 // "count"
+    intc_0 // 0
     app_global_put
-    // tests/artifacts/Arrays/static_size.py:32
+    // tests/artifacts/Arrays/static_size.py:45
     // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
     callsub xtra
-    // tests/artifacts/Arrays/static_size.py:33
+    // tests/artifacts/Arrays/static_size.py:46
     // Point(x=x1, y=y1, other=self.xtra()),
     callsub xtra
-    // tests/artifacts/Arrays/static_size.py:34
+    // tests/artifacts/Arrays/static_size.py:47
     // Point(x=x2, y=y2, other=self.xtra()),
     callsub xtra
-    // tests/artifacts/Arrays/static_size.py:32
-    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
-    uncover 11
+    // tests/artifacts/Arrays/static_size.py:44-48
+    // path = ReferenceArray(
+    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
+    //     Point(x=x1, y=y1, other=self.xtra()),
+    //     Point(x=x2, y=y2, other=self.xtra()),
+    // )
+    uncover 14
     itob
-    pushbytes 0x00000000000000000000000000000000
-    swap
-    concat
-    uncover 11
+    uncover 14
     itob
     concat
-    uncover 10
+    uncover 13
     concat
-    uncover 9
+    uncover 12
+    concat
+    dig 11
+    len
+    pushint 64 // 64
+    <=
+    assert // overflow
+    pushint 64 // 64
+    bzero
+    uncover 12
+    dig 1
+    b|
+    uncover 2
+    swap
+    concat
+    pushbytes 0x00000000000000000000000000000000
+    swap
     concat
-    // tests/artifacts/Arrays/static_size.py:33
-    // Point(x=x1, y=y1, other=self.xtra()),
     frame_dig -3
     itob
     frame_dig -4
     swap
     concat
-    uncover 9
+    uncover 12
     itob
-    concat
-    uncover 8
+    uncover 12
     itob
     concat
-    uncover 7
+    uncover 11
+    concat
+    uncover 10
+    concat
+    dig 9
+    len
+    pushint 64 // 64
+    <=
+    assert // overflow
+    uncover 9
+    dig 4
+    b|
     concat
-    uncover 6
     concat
-    // tests/artifacts/Arrays/static_size.py:31-35
-    // path = Array(
-    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
-    //     Point(x=x1, y=y1, other=self.xtra()),
-    //     Point(x=x2, y=y2, other=self.xtra()),
-    // )
     concat
-    // tests/artifacts/Arrays/static_size.py:34
-    // Point(x=x2, y=y2, other=self.xtra()),
     frame_dig -1
     itob
     frame_dig -2
     swap
     concat
-    uncover 5
+    uncover 7
     itob
-    concat
-    uncover 4
+    uncover 7
     itob
     concat
-    uncover 3
+    uncover 6
     concat
-    uncover 2
+    uncover 5
+    concat
+    dig 4
+    len
+    pushint 64 // 64
+    <=
+    assert // overflow
+    uncover 4
+    uncover 4
+    b|
     concat
-    // tests/artifacts/Arrays/static_size.py:31-35
-    // path = Array(
-    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
-    //     Point(x=x1, y=y1, other=self.xtra()),
-    //     Point(x=x2, y=y2, other=self.xtra()),
-    // )
     concat
-    // tests/artifacts/Arrays/static_size.py:36
+    concat
+    // tests/artifacts/Arrays/static_size.py:49
     // for i in urange(3):
-    intc_1 // 0
+    intc_0 // 0
 
 test_array_for_header@1:
-    // tests/artifacts/Arrays/static_size.py:36
+    // tests/artifacts/Arrays/static_size.py:49
     // for i in urange(3):
     frame_dig 9
     pushint 3 // 3
     <
     bz test_array_after_for@4
     frame_dig 8
-    // tests/artifacts/Arrays/static_size.py:37
+    // tests/artifacts/Arrays/static_size.py:50
     // assert path[i].other.b == i + 1
     frame_dig 9
     dup
     cover 2
-    intc_3 // 80
+    intc 4 // 144
     *
-    intc_3 // 80
-    extract3
+    intc 4 // 144
+    extract3 // on error: index access is out of bounds
+    extract 16 128
     dup
-    pushint 24 // 24
+    intc_2 // 8
     extract_uint64
+    swap
+    extract 48 16
     dig 2
-    intc_0 // 1
+    intc_1 // 1
     +
-    swap
+    uncover 2
     dig 1
     ==
     assert
-    // tests/artifacts/Arrays/static_size.py:38
+    // tests/artifacts/Arrays/static_size.py:51
     // assert path[i].other.d.foo == i + 2
-    swap
-    extract 64 16
-    dup
-    extract 0 8 // on error: Index access is out of bounds
+    dig 1
+    extract 0 8
     uncover 3
     pushint 2 // 2
     +
     itob
     b==
     assert
-    // tests/artifacts/Arrays/static_size.py:39
+    // tests/artifacts/Arrays/static_size.py:52
     // assert path[i].other.d.bar == (i + 1) * (i + 1)
-    extract 8 8 // on error: Index access is out of bounds
+    swap
+    extract 8 8
     dig 1
     dig 2
     *
@@ -323,27 +449,27 @@ test_array_for_header@1:
 
 test_array_after_for@4:
     frame_dig 8
-    // tests/artifacts/Arrays/static_size.py:41
+    // tests/artifacts/Arrays/static_size.py:54
     // Box(ImmutableArray[Point], key="a").value = path.freeze()
     dup
     len
-    intc_3 // 80
+    intc 4 // 144
     /
     dup
-    frame_bury 4
+    frame_bury 2
     itob
     extract 6 2
     dig 1
     concat
-    bytec_3 // "a"
+    pushbytes "a"
     box_del
     pop
-    bytec_3 // "a"
+    pushbytes "a"
     swap
     box_put
-    // tests/artifacts/Arrays/static_size.py:122
+    // tests/artifacts/Arrays/static_size.py:167
     // last_point = path[0]
-    extract 0 80
+    extract 0 144 // on error: index access is out of bounds
     dup
     frame_bury 0
     dup
@@ -351,78 +477,78 @@ test_array_after_for@4:
     frame_bury 1
     intc_2 // 8
     extract_uint64
-    frame_bury 3
-    // tests/artifacts/Arrays/static_size.py:123
+    frame_bury 4
+    // tests/artifacts/Arrays/static_size.py:168
     // length = UInt64()
-    intc_1 // 0
+    intc_0 // 0
     frame_bury 5
-    // tests/artifacts/Arrays/static_size.py:124
+    // tests/artifacts/Arrays/static_size.py:169
     // for point_idx in urange(1, path.length):
-    intc_0 // 1
+    intc_1 // 1
     frame_bury 7
 
 test_array_for_header@6:
-    // tests/artifacts/Arrays/static_size.py:124
+    // tests/artifacts/Arrays/static_size.py:169
     // for point_idx in urange(1, path.length):
     frame_dig 7
-    frame_dig 4
+    frame_dig 2
     <
     bz test_array_after_for@14
     frame_dig 8
-    // tests/artifacts/Arrays/static_size.py:125
+    // tests/artifacts/Arrays/static_size.py:170
     // point = path[point_idx]
     frame_dig 7
-    intc_3 // 80
+    intc 4 // 144
     *
-    intc_3 // 80
-    extract3
+    intc 4 // 144
+    extract3 // on error: index access is out of bounds
     dupn 2
     extract 0 8
     swap
     intc_2 // 8
     extract_uint64
     frame_bury 6
-    // tests/artifacts/Arrays/static_size.py:126
+    // tests/artifacts/Arrays/static_size.py:171
     // if point.x < last_point.x:
     frame_dig 1
     b<
     bz test_array_else_body@9
-    // tests/artifacts/Arrays/static_size.py:127
+    // tests/artifacts/Arrays/static_size.py:172
     // dx = last_point.x.native - point.x.native
     frame_dig 0
-    // tests/artifacts/Arrays/static_size.py:122
+    // tests/artifacts/Arrays/static_size.py:167
     // last_point = path[0]
-    intc_1 // 0
-    // tests/artifacts/Arrays/static_size.py:127
+    intc_0 // 0
+    // tests/artifacts/Arrays/static_size.py:172
     // dx = last_point.x.native - point.x.native
     extract_uint64
     swap
-    // tests/artifacts/Arrays/static_size.py:125
+    // tests/artifacts/Arrays/static_size.py:170
     // point = path[point_idx]
-    intc_1 // 0
-    // tests/artifacts/Arrays/static_size.py:127
+    intc_0 // 0
+    // tests/artifacts/Arrays/static_size.py:172
     // dx = last_point.x.native - point.x.native
     extract_uint64
     -
-    frame_bury 2
+    frame_bury 3
 
 test_array_after_if_else@10:
-    // tests/artifacts/Arrays/static_size.py:130
+    // tests/artifacts/Arrays/static_size.py:175
     // if point.y < last_point.y:
     frame_dig 6
-    frame_dig 3
+    frame_dig 4
     <
     bz test_array_else_body@12
-    // tests/artifacts/Arrays/static_size.py:131
+    // tests/artifacts/Arrays/static_size.py:176
     // dy = last_point.y - point.y
-    frame_dig 3
+    frame_dig 4
     frame_dig 6
     -
 
 test_array_after_if_else@13:
-    // tests/artifacts/Arrays/static_size.py:134
+    // tests/artifacts/Arrays/static_size.py:179
     // length += op.sqrt(dx * dx + dy * dy)
-    frame_dig 2
+    frame_dig 3
     dup
     *
     swap
@@ -433,42 +559,42 @@ test_array_after_if_else@13:
     frame_dig 5
     +
     frame_bury 5
-    // tests/artifacts/Arrays/static_size.py:124
+    // tests/artifacts/Arrays/static_size.py:169
     // for point_idx in urange(1, path.length):
     frame_dig 7
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 7
     b test_array_for_header@6
 
 test_array_else_body@12:
-    // tests/artifacts/Arrays/static_size.py:133
+    // tests/artifacts/Arrays/static_size.py:178
     // dy = point.y - last_point.y
     frame_dig 6
-    frame_dig 3
+    frame_dig 4
     -
     b test_array_after_if_else@13
 
 test_array_else_body@9:
-    // tests/artifacts/Arrays/static_size.py:125
+    // tests/artifacts/Arrays/static_size.py:170
     // point = path[point_idx]
-    intc_1 // 0
-    // tests/artifacts/Arrays/static_size.py:129
+    intc_0 // 0
+    // tests/artifacts/Arrays/static_size.py:174
     // dx = point.x.native - last_point.x.native
     extract_uint64
     frame_dig 0
-    // tests/artifacts/Arrays/static_size.py:122
+    // tests/artifacts/Arrays/static_size.py:167
     // last_point = path[0]
-    intc_1 // 0
-    // tests/artifacts/Arrays/static_size.py:129
+    intc_0 // 0
+    // tests/artifacts/Arrays/static_size.py:174
     // dx = point.x.native - last_point.x.native
     extract_uint64
     -
-    frame_bury 2
+    frame_bury 3
     b test_array_after_if_else@10
 
 test_array_after_for@14:
-    // tests/artifacts/Arrays/static_size.py:42
+    // tests/artifacts/Arrays/static_size.py:55
     // return path_length(path)
     frame_dig 5
     frame_bury 0
@@ -477,81 +603,85 @@ test_array_after_for@14:
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_tuple(some_more.0: bytes, some_more.1: bytes) -> bytes:
 test_extend_from_tuple:
-    // tests/artifacts/Arrays/static_size.py:44-45
+    // tests/artifacts/Arrays/static_size.py:57-58
     // @arc4.abimethod()
     // def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
     proto 2 1
-    // tests/artifacts/Arrays/static_size.py:47
+    // tests/artifacts/Arrays/static_size.py:60
     // arr.extend(some_more)
     frame_dig -2
     frame_dig -1
     concat
-    // tests/artifacts/Arrays/static_size.py:48
+    // tests/artifacts/Arrays/static_size.py:61
     // last = arr[-1]
     dup
     len
-    pushint 16 // 16
+    intc_3 // 16
     /
     dup
-    intc_0 // 1
+    intc_1 // 1
     -
-    pushint 16 // 16
+    intc_3 // 16
     *
     dig 2
     swap
-    pushint 16 // 16
-    extract3
-    extract 0 16
-    // tests/artifacts/Arrays/static_size.py:49
+    intc_3 // 16
+    extract3 // on error: index access is out of bounds
+    // tests/artifacts/Arrays/static_size.py:62
     // assert last == some_more[1]
     dup
     frame_dig -1
     ==
     assert
-    // tests/artifacts/Arrays/static_size.py:50
+    // tests/artifacts/Arrays/static_size.py:63
     // result = arr.freeze()
     swap
     itob
     extract 6 2
     uncover 2
     concat
-    // tests/artifacts/Arrays/static_size.py:51
+    // tests/artifacts/Arrays/static_size.py:64
     // assert result[-1] == last
     dup
-    intc_1 // 0
+    intc_0 // 0
     extract_uint16
-    intc_0 // 1
+    intc_1 // 1
     -
     dig 1
     extract 2 0
     swap
-    pushint 16 // 16
+    intc_3 // 16
     *
-    pushint 16 // 16
-    extract3 // on error: Index access is out of bounds
+    intc_3 // 16
+    extract3 // on error: index access is out of bounds
     uncover 2
     ==
     assert
-    // tests/artifacts/Arrays/static_size.py:52
+    // tests/artifacts/Arrays/static_size.py:65
     // return result
     retsub
 
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_arc4_tuple(some_more: bytes) -> bytes:
 test_extend_from_arc4_tuple:
-    // tests/artifacts/Arrays/static_size.py:54-57
+    // tests/artifacts/Arrays/static_size.py:67-70
     // @arc4.abimethod()
     // def test_extend_from_arc4_tuple(
     //     self, some_more: arc4.Tuple[More, More]
     // ) -> ImmutableArray[More]:
     proto 1 1
-    // tests/artifacts/Arrays/static_size.py:59
+    // tests/artifacts/Arrays/static_size.py:72
     // arr.extend(some_more)
     frame_dig -1
     pop
-    // tests/artifacts/Arrays/static_size.py:60
+    // tests/artifacts/Arrays/static_size.py:73
     // return arr.freeze()
-    pushbytes 0x0002
+    frame_dig -1
+    len
+    intc_3 // 16
+    /
+    itob
+    extract 6 2
     frame_dig -1
     concat
     retsub
@@ -559,68 +689,84 @@ test_extend_from_arc4_tuple:
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.test_bool_array(length: uint64) -> uint64:
 test_bool_array:
-    // tests/artifacts/Arrays/static_size.py:62-63
+    // tests/artifacts/Arrays/static_size.py:75-76
     // @arc4.abimethod()
     // def test_bool_array(self, length: UInt64) -> UInt64:
     proto 1 1
-    bytec_2 // ""
-    // tests/artifacts/Arrays/static_size.py:64
-    // arr = Array[bool]()
+    bytec_3 // ""
+    // tests/artifacts/Arrays/static_size.py:77
+    // arr = ReferenceArray[bool]()
     dupn 4
-    // tests/artifacts/Arrays/static_size.py:67
+    // tests/artifacts/Arrays/static_size.py:80
     // for i in urange(1, length + 1):
     frame_dig -1
-    intc_0 // 1
+    intc_1 // 1
     +
-    intc_0 // 1
+    intc_1 // 1
 
 test_bool_array_for_header@1:
-    // tests/artifacts/Arrays/static_size.py:67
+    // tests/artifacts/Arrays/static_size.py:80
     // for i in urange(1, length + 1):
     frame_dig 6
     frame_dig 5
     <
     bz test_bool_array_after_for@4
-    // tests/artifacts/Arrays/static_size.py:68
+    // tests/artifacts/Arrays/static_size.py:81
     // arr.append(i % 2 == 0)
     frame_dig 6
     dup
     pushint 2 // 2
     %
     !
-    pushbytess 0x00 0x80 // 0x00, 0x80
-    uncover 2
-    select
     frame_dig 4
     swap
+    bytec_2 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
     concat // on error: max array length exceeded
     frame_bury 4
-    // tests/artifacts/Arrays/static_size.py:67
+    // tests/artifacts/Arrays/static_size.py:80
     // for i in urange(1, length + 1):
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 6
     b test_bool_array_for_header@1
 
 test_bool_array_after_for@4:
     frame_dig 4
-    // tests/artifacts/Arrays/static_size.py:69
+    dupn 2
+    // tests/artifacts/Arrays/static_size.py:82
     // assert arr.length == length, "expected correct length"
     len
-    dup
-    frame_bury 0
     frame_dig -1
     ==
     assert // expected correct length
-    // tests/artifacts/Arrays/static_size.py:70
+    dig 1
+    // tests/artifacts/Arrays/static_size.py:85
+    // arr2.extend(arr)
+    concat // on error: max array length exceeded
+    // tests/artifacts/Arrays/static_size.py:86
+    // assert arr2.length == length * 2, "expected correct length"
+    len
+    frame_dig -1
+    pushint 2 // 2
+    *
+    ==
+    assert // expected correct length
+    // tests/artifacts/Arrays/static_size.py:88
     // count = UInt64(0)
-    intc_1 // 0
+    intc_0 // 0
     frame_bury 1
-    intc_1 // 0
+    // tests/artifacts/Arrays/static_size.py:89
+    // for val in arr:
+    len
+    frame_bury 0
+    intc_0 // 0
     frame_bury 3
 
 test_bool_array_for_header@5:
-    // tests/artifacts/Arrays/static_size.py:71
+    // tests/artifacts/Arrays/static_size.py:89
     // for val in arr:
     frame_dig 3
     frame_dig 0
@@ -628,19 +774,19 @@ test_bool_array_for_header@5:
     bz test_bool_array_after_for@10
     frame_dig 4
     frame_dig 3
-    intc_0 // 1
-    extract3
-    intc_1 // 0
+    intc_1 // 1
+    extract3 // on error: index access is out of bounds
+    intc_0 // 0
     getbit
     frame_dig 1
     frame_bury 2
-    // tests/artifacts/Arrays/static_size.py:72
+    // tests/artifacts/Arrays/static_size.py:90
     // if val:
     bz test_bool_array_after_if_else@8
-    // tests/artifacts/Arrays/static_size.py:73
+    // tests/artifacts/Arrays/static_size.py:91
     // count += 1
     frame_dig 1
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 2
 
@@ -648,13 +794,13 @@ test_bool_array_after_if_else@8:
     frame_dig 2
     frame_bury 1
     frame_dig 3
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 3
     b test_bool_array_for_header@5
 
 test_bool_array_after_for@10:
-    // tests/artifacts/Arrays/static_size.py:74
+    // tests/artifacts/Arrays/static_size.py:92
     // return count
     frame_dig 1
     frame_bury 0
@@ -663,29 +809,29 @@ test_bool_array_after_for@10:
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_conversion(length: uint64) -> bytes:
 test_arc4_conversion:
-    // tests/artifacts/Arrays/static_size.py:76-77
+    // tests/artifacts/Arrays/static_size.py:94-95
     // @arc4.abimethod()
     // def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
     proto 1 1
-    bytec_2 // ""
-    // tests/artifacts/Arrays/static_size.py:78
-    // arr = Array[arc4.UInt64]()
+    bytec_3 // ""
+    // tests/artifacts/Arrays/static_size.py:96
+    // arr = ReferenceArray[arc4.UInt64]()
     dupn 4
-    // tests/artifacts/Arrays/static_size.py:81
+    // tests/artifacts/Arrays/static_size.py:99
     // for i in urange(1, length + 1):
     frame_dig -1
-    intc_0 // 1
+    intc_1 // 1
     +
-    intc_0 // 1
+    intc_1 // 1
 
 test_arc4_conversion_for_header@1:
-    // tests/artifacts/Arrays/static_size.py:81
+    // tests/artifacts/Arrays/static_size.py:99
     // for i in urange(1, length + 1):
     frame_dig 6
     frame_dig 5
     <
     bz test_arc4_conversion_after_for@4
-    // tests/artifacts/Arrays/static_size.py:82
+    // tests/artifacts/Arrays/static_size.py:100
     // arr.append(arc4.UInt64(i))
     frame_dig 6
     dup
@@ -694,16 +840,16 @@ test_arc4_conversion_for_header@1:
     swap
     concat // on error: max array length exceeded
     frame_bury 4
-    // tests/artifacts/Arrays/static_size.py:81
+    // tests/artifacts/Arrays/static_size.py:99
     // for i in urange(1, length + 1):
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 6
     b test_arc4_conversion_for_header@1
 
 test_arc4_conversion_after_for@4:
     frame_dig 4
-    // tests/artifacts/Arrays/static_size.py:83
+    // tests/artifacts/Arrays/static_size.py:101
     // assert arr.length == length, "expected correct length"
     len
     intc_2 // 8
@@ -713,15 +859,15 @@ test_arc4_conversion_after_for@4:
     frame_dig -1
     ==
     assert // expected correct length
-    // tests/artifacts/Arrays/static_size.py:84
+    // tests/artifacts/Arrays/static_size.py:102
     // count = UInt64(0)
-    intc_1 // 0
+    intc_0 // 0
     frame_bury 1
-    intc_1 // 0
+    intc_0 // 0
     frame_bury 3
 
 test_arc4_conversion_for_header@5:
-    // tests/artifacts/Arrays/static_size.py:85
+    // tests/artifacts/Arrays/static_size.py:103
     // for val in arr:
     frame_dig 3
     frame_dig 0
@@ -732,19 +878,18 @@ test_arc4_conversion_for_header@5:
     intc_2 // 8
     *
     intc_2 // 8
-    extract3
-    extract 0 8
-    // tests/artifacts/Arrays/static_size.py:86
+    extract3 // on error: index access is out of bounds
+    // tests/artifacts/Arrays/static_size.py:104
     // if val:
-    bytec_2 // 0x
+    bytec_3 // 0x
     b!=
     frame_dig 1
     frame_bury 2
     bz test_arc4_conversion_after_if_else@8
-    // tests/artifacts/Arrays/static_size.py:87
+    // tests/artifacts/Arrays/static_size.py:105
     // count += 1
     frame_dig 1
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 2
 
@@ -752,24 +897,28 @@ test_arc4_conversion_after_if_else@8:
     frame_dig 2
     frame_bury 1
     frame_dig 3
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 3
     b test_arc4_conversion_for_header@5
 
 test_arc4_conversion_after_for@10:
+    // tests/artifacts/Arrays/static_size.py:107
+    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
+    bytec 4 // 0x0000
     frame_dig 4
-    // tests/artifacts/Arrays/static_size.py:90
+    // tests/artifacts/Arrays/static_size.py:108
     // arc4_arr.extend(arr)
+    concat // on error: max array length exceeded
     dup
+    extract 2 0
     len
     intc_2 // 8
     /
     itob
     extract 6 2
-    swap
-    concat
-    // tests/artifacts/Arrays/static_size.py:92
+    replace2 0
+    // tests/artifacts/Arrays/static_size.py:110
     // return arc4_arr
     frame_bury 0
     retsub
@@ -777,28 +926,28 @@ test_arc4_conversion_after_for@10:
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.sum_array(arc4_arr: bytes) -> uint64:
 sum_array:
-    // tests/artifacts/Arrays/static_size.py:94-95
+    // tests/artifacts/Arrays/static_size.py:112-113
     // @arc4.abimethod()
     // def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
     proto 1 1
-    // tests/artifacts/Arrays/static_size.py:97
+    // tests/artifacts/Arrays/static_size.py:115
     // arr.extend(arc4_arr)
     frame_dig -1
     extract 2 0
     dup
-    // tests/artifacts/Arrays/static_size.py:99
+    // tests/artifacts/Arrays/static_size.py:117
     // total = UInt64(0)
-    intc_1 // 0
+    intc_0 // 0
     swap
-    // tests/artifacts/Arrays/static_size.py:100
+    // tests/artifacts/Arrays/static_size.py:118
     // for item in arr:
     len
     intc_2 // 8
     /
-    intc_1 // 0
+    intc_0 // 0
 
 sum_array_for_header@1:
-    // tests/artifacts/Arrays/static_size.py:100
+    // tests/artifacts/Arrays/static_size.py:118
     // for item in arr:
     frame_dig 3
     frame_dig 2
@@ -810,86 +959,275 @@ sum_array_for_header@1:
     cover 2
     intc_2 // 8
     *
-    intc_2 // 8
-    extract3
-    intc_1 // 0
-    // tests/artifacts/Arrays/static_size.py:101
+    // tests/artifacts/Arrays/static_size.py:119
     // total += item.native
     extract_uint64
     frame_dig 1
     +
     frame_bury 1
-    intc_0 // 1
+    intc_1 // 1
     +
     frame_bury 3
     b sum_array_for_header@1
 
 sum_array_after_for@4:
-    // tests/artifacts/Arrays/static_size.py:103
+    // tests/artifacts/Arrays/static_size.py:121
     // return total
     frame_dig 1
     frame_bury 0
     retsub
 
 
-// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes:
+// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes, bytes:
 xtra:
-    // tests/artifacts/Arrays/static_size.py:107
+    // tests/artifacts/Arrays/static_size.py:125
     // self.count += 1
-    intc_1 // 0
-    bytec_0 // "count"
+    intc_0 // 0
+    bytec_1 // "count"
     app_global_get_ex
     assert // check self.count exists
-    intc_0 // 1
+    intc_1 // 1
     +
-    bytec_0 // "count"
-    swap
+    bytec_1 // "count"
+    dig 1
     app_global_put
-    // tests/artifacts/Arrays/static_size.py:109
+    // tests/artifacts/Arrays/static_size.py:127
     // a=Txn.num_app_args,
     txn NumAppArgs
-    // tests/artifacts/Arrays/static_size.py:110
-    // b=self.count,
-    intc_1 // 0
-    bytec_0 // "count"
-    app_global_get_ex
-    assert // check self.count exists
-    // tests/artifacts/Arrays/static_size.py:111
+    // tests/artifacts/Arrays/static_size.py:129
     // c=Txn.sender,
     txn Sender
-    // tests/artifacts/Arrays/static_size.py:112
+    // tests/artifacts/Arrays/static_size.py:130
     // d=self.more(),
     callsub more
-    // tests/artifacts/Arrays/static_size.py:108-113
+    // tests/artifacts/Arrays/static_size.py:131
+    // e=BigUInt(self.count),
+    intc_0 // 0
+    bytec_1 // "count"
+    app_global_get_ex
+    assert // check self.count exists
+    itob
+    // tests/artifacts/Arrays/static_size.py:126-132
     // return Xtra(
     //     a=Txn.num_app_args,
     //     b=self.count,
     //     c=Txn.sender,
     //     d=self.more(),
+    //     e=BigUInt(self.count),
     // )
+    uncover 3
+    cover 4
     retsub
 
 
 // tests.artifacts.Arrays.static_size.StaticSizeContract.more() -> bytes:
 more:
-    // tests/artifacts/Arrays/static_size.py:117
+    // tests/artifacts/Arrays/static_size.py:136
     // return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
-    intc_1 // 0
-    bytec_0 // "count"
+    intc_0 // 0
+    bytec_1 // "count"
     app_global_get_ex
     assert // check self.count exists
-    intc_0 // 1
+    dup
+    intc_1 // 1
     +
     itob
-    intc_1 // 0
-    bytec_0 // "count"
-    app_global_get_ex
-    assert // check self.count exists
-    intc_1 // 0
-    bytec_0 // "count"
-    app_global_get_ex
-    assert // check self.count exists
+    dig 1
+    uncover 2
     *
     itob
     concat
     retsub
+
+
+// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_bool() -> bytes:
+test_arc4_bool:
+    // tests/artifacts/Arrays/static_size.py:138-139
+    // @arc4.abimethod()
+    // def test_arc4_bool(self) -> ImmutableArray[arc4.Bool]:
+    proto 0 1
+    // tests/artifacts/Arrays/static_size.py:141
+    // arr.append(arc4.Bool(Txn.sender == Txn.receiver))
+    txn Sender
+    txn Receiver
+    ==
+    bytec_2 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
+    // tests/artifacts/Arrays/static_size.py:142
+    // arr.append(arc4.Bool(Txn.sender != Txn.receiver))
+    txn Sender
+    txn Receiver
+    !=
+    bytec_2 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
+    concat // on error: max array length exceeded
+    dupn 2
+    uncover 2
+    // tests/artifacts/Arrays/static_size.py:145
+    // dyn_arr.extend(arr)
+    dup
+    len
+    // tests/artifacts/Arrays/static_size.py:144
+    // dyn_arr = arc4.DynamicArray[arc4.Bool]()
+    bytec 4 // 0x0000
+    // tests/artifacts/Arrays/static_size.py:145
+    // dyn_arr.extend(arr)
+    cover 2
+    intc_2 // 8
+    callsub dynamic_array_concat_bits
+    dup
+    cover 2
+    // tests/artifacts/Arrays/static_size.py:146
+    // assert dyn_arr.length == 2, "expected correct length"
+    dup
+    intc_0 // 0
+    extract_uint16
+    dup
+    cover 3
+    dup
+    pushint 2 // 2
+    ==
+    assert // expected correct length
+    // tests/artifacts/Arrays/static_size.py:147
+    // assert dyn_arr.bytes.length == 3, "expected 3 bytes"
+    dig 1
+    len
+    pushint 3 // 3
+    ==
+    assert // expected 3 bytes
+    // tests/artifacts/Arrays/static_size.py:148
+    // assert dyn_arr[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
+    dup
+    assert // index access is out of bounds
+    dig 1
+    intc_3 // 16
+    getbit
+    bytec_2 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
+    intc_0 // 0
+    getbit
+    txn Sender
+    txn Receiver
+    ==
+    ==
+    assert // expected correct value at 0
+    // tests/artifacts/Arrays/static_size.py:149
+    // assert dyn_arr[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
+    intc_1 // 1
+    >
+    assert // index access is out of bounds
+    pushint 17 // 17
+    getbit
+    bytec_2 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
+    intc_0 // 0
+    getbit
+    txn Sender
+    txn Receiver
+    !=
+    ==
+    assert // expected correct value at 1
+    intc_0 // 0
+
+test_arc4_bool_for_header@1:
+    // tests/artifacts/Arrays/static_size.py:152-154
+    // # note: not supported currently
+    // # arr2.extend(dyn_array)
+    // for b in dyn_arr:
+    frame_dig 4
+    frame_dig 2
+    <
+    bz test_arc4_bool_after_for@4
+    frame_dig 4
+    dup
+    intc_3 // 16
+    +
+    frame_dig 1
+    swap
+    getbit
+    bytec_2 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
+    frame_dig 3
+    // tests/artifacts/Arrays/static_size.py:155
+    // arr2.append(b)
+    swap
+    concat // on error: max array length exceeded
+    frame_bury 3
+    intc_1 // 1
+    +
+    frame_bury 4
+    b test_arc4_bool_for_header@1
+
+test_arc4_bool_after_for@4:
+    frame_dig 3
+    // tests/artifacts/Arrays/static_size.py:156
+    // assert arr2.length == 4, "expected correct length"
+    dup
+    len
+    pushint 4 // 4
+    ==
+    assert // expected correct length
+    // tests/artifacts/Arrays/static_size.py:157
+    // assert arr2[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
+    dup
+    extract 0 1 // on error: index access is out of bounds
+    intc_0 // 0
+    getbit
+    txn Sender
+    txn Receiver
+    ==
+    ==
+    assert // expected correct value at 0
+    // tests/artifacts/Arrays/static_size.py:158
+    // assert arr2[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
+    dup
+    extract 1 1 // on error: index access is out of bounds
+    intc_0 // 0
+    getbit
+    txn Sender
+    txn Receiver
+    !=
+    ==
+    assert // expected correct value at 1
+    // tests/artifacts/Arrays/static_size.py:159
+    // assert arr2[2] == (Txn.sender == Txn.receiver), "expected correct value at 2"
+    dup
+    extract 2 1 // on error: index access is out of bounds
+    intc_0 // 0
+    getbit
+    txn Sender
+    txn Receiver
+    ==
+    ==
+    assert // expected correct value at 2
+    // tests/artifacts/Arrays/static_size.py:160
+    // assert arr2[3] == (Txn.sender != Txn.receiver), "expected correct value at 3"
+    extract 3 1 // on error: index access is out of bounds
+    intc_0 // 0
+    getbit
+    txn Sender
+    txn Receiver
+    !=
+    ==
+    assert // expected correct value at 3
+    frame_dig 0
+    // tests/artifacts/Arrays/static_size.py:162
+    // return arr.freeze()
+    dup
+    len
+    bytec 4 // 0x0000
+    cover 2
+    intc_2 // 8
+    callsub dynamic_array_concat_bits
+    frame_bury 0
+    retsub
diff --git a/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json b/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json
index 3d448f5b..c3d16579 100644
--- a/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json
+++ b/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json
@@ -29,10 +29,15 @@
             "call_config": {
                 "no_op": "CALL"
             }
+        },
+        "test_arc4_bool()bool[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.Arrays.static_size.StaticSizeContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0 8 80
    bytecblock "count" 0x151f7c75 0x "a"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/Arrays/static_size.py:26
    // self.count = UInt64(0)
    bytec_0 // "count"
    intc_1 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@11
    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64"
    txna ApplicationArgs 0
    match main_test_array_route@5 main_test_extend_from_tuple_route@6 main_test_extend_from_arc4_tuple_route@7 main_test_bool_array_route@8 main_test_arc4_conversion_route@9 main_sum_array_route@10

main_after_if_else@13:
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    intc_1 // 0
    return

main_sum_array_route@10:
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    callsub sum_array
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_arc4_conversion_route@9:
    // tests/artifacts/Arrays/static_size.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:76
    // @arc4.abimethod()
    callsub test_arc4_conversion
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_bool_array_route@8:
    // tests/artifacts/Arrays/static_size.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:62
    // @arc4.abimethod()
    callsub test_bool_array
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_extend_from_arc4_tuple_route@7:
    // tests/artifacts/Arrays/static_size.py:54
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:54
    // @arc4.abimethod()
    callsub test_extend_from_arc4_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_extend_from_tuple_route@6:
    // tests/artifacts/Arrays/static_size.py:44
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 16 // on error: Index access is out of bounds
    swap
    extract 16 16 // on error: Index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:44
    // @arc4.abimethod()
    callsub test_extend_from_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_array_route@5:
    // tests/artifacts/Arrays/static_size.py:28
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/Arrays/static_size.py:28
    // @arc4.abimethod()
    callsub test_array
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@11:
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@13
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_array(x1: bytes, y1: uint64, x2: bytes, y2: uint64) -> uint64:
test_array:
    // tests/artifacts/Arrays/static_size.py:28-29
    // @arc4.abimethod()
    // def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
    proto 4 1
    intc_1 // 0
    dup
    bytec_2 // ""
    dupn 5
    // tests/artifacts/Arrays/static_size.py:30
    // self.count = UInt64(0)
    bytec_0 // "count"
    intc_1 // 0
    app_global_put
    // tests/artifacts/Arrays/static_size.py:32
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:33
    // Point(x=x1, y=y1, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:34
    // Point(x=x2, y=y2, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:32
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    uncover 11
    itob
    pushbytes 0x00000000000000000000000000000000
    swap
    concat
    uncover 11
    itob
    concat
    uncover 10
    concat
    uncover 9
    concat
    // tests/artifacts/Arrays/static_size.py:33
    // Point(x=x1, y=y1, other=self.xtra()),
    frame_dig -3
    itob
    frame_dig -4
    swap
    concat
    uncover 9
    itob
    concat
    uncover 8
    itob
    concat
    uncover 7
    concat
    uncover 6
    concat
    // tests/artifacts/Arrays/static_size.py:31-35
    // path = Array(
    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //     Point(x=x1, y=y1, other=self.xtra()),
    //     Point(x=x2, y=y2, other=self.xtra()),
    // )
    concat
    // tests/artifacts/Arrays/static_size.py:34
    // Point(x=x2, y=y2, other=self.xtra()),
    frame_dig -1
    itob
    frame_dig -2
    swap
    concat
    uncover 5
    itob
    concat
    uncover 4
    itob
    concat
    uncover 3
    concat
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:31-35
    // path = Array(
    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //     Point(x=x1, y=y1, other=self.xtra()),
    //     Point(x=x2, y=y2, other=self.xtra()),
    // )
    concat
    // tests/artifacts/Arrays/static_size.py:36
    // for i in urange(3):
    intc_1 // 0

test_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:36
    // for i in urange(3):
    frame_dig 9
    pushint 3 // 3
    <
    bz test_array_after_for@4
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:37
    // assert path[i].other.b == i + 1
    frame_dig 9
    dup
    cover 2
    intc_3 // 80
    *
    intc_3 // 80
    extract3
    dup
    pushint 24 // 24
    extract_uint64
    dig 2
    intc_0 // 1
    +
    swap
    dig 1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:38
    // assert path[i].other.d.foo == i + 2
    swap
    extract 64 16
    dup
    extract 0 8 // on error: Index access is out of bounds
    uncover 3
    pushint 2 // 2
    +
    itob
    b==
    assert
    // tests/artifacts/Arrays/static_size.py:39
    // assert path[i].other.d.bar == (i + 1) * (i + 1)
    extract 8 8 // on error: Index access is out of bounds
    dig 1
    dig 2
    *
    itob
    b==
    assert
    frame_bury 9
    b test_array_for_header@1

test_array_after_for@4:
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:41
    // Box(ImmutableArray[Point], key="a").value = path.freeze()
    dup
    len
    intc_3 // 80
    /
    dup
    frame_bury 4
    itob
    extract 6 2
    dig 1
    concat
    bytec_3 // "a"
    box_del
    pop
    bytec_3 // "a"
    swap
    box_put
    // tests/artifacts/Arrays/static_size.py:122
    // last_point = path[0]
    extract 0 80
    dup
    frame_bury 0
    dup
    extract 0 8
    frame_bury 1
    intc_2 // 8
    extract_uint64
    frame_bury 3
    // tests/artifacts/Arrays/static_size.py:123
    // length = UInt64()
    intc_1 // 0
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:124
    // for point_idx in urange(1, path.length):
    intc_0 // 1
    frame_bury 7

test_array_for_header@6:
    // tests/artifacts/Arrays/static_size.py:124
    // for point_idx in urange(1, path.length):
    frame_dig 7
    frame_dig 4
    <
    bz test_array_after_for@14
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:125
    // point = path[point_idx]
    frame_dig 7
    intc_3 // 80
    *
    intc_3 // 80
    extract3
    dupn 2
    extract 0 8
    swap
    intc_2 // 8
    extract_uint64
    frame_bury 6
    // tests/artifacts/Arrays/static_size.py:126
    // if point.x < last_point.x:
    frame_dig 1
    b<
    bz test_array_else_body@9
    // tests/artifacts/Arrays/static_size.py:127
    // dx = last_point.x.native - point.x.native
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:122
    // last_point = path[0]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:127
    // dx = last_point.x.native - point.x.native
    extract_uint64
    swap
    // tests/artifacts/Arrays/static_size.py:125
    // point = path[point_idx]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:127
    // dx = last_point.x.native - point.x.native
    extract_uint64
    -
    frame_bury 2

test_array_after_if_else@10:
    // tests/artifacts/Arrays/static_size.py:130
    // if point.y < last_point.y:
    frame_dig 6
    frame_dig 3
    <
    bz test_array_else_body@12
    // tests/artifacts/Arrays/static_size.py:131
    // dy = last_point.y - point.y
    frame_dig 3
    frame_dig 6
    -

test_array_after_if_else@13:
    // tests/artifacts/Arrays/static_size.py:134
    // length += op.sqrt(dx * dx + dy * dy)
    frame_dig 2
    dup
    *
    swap
    dup
    *
    +
    sqrt
    frame_dig 5
    +
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:124
    // for point_idx in urange(1, path.length):
    frame_dig 7
    intc_0 // 1
    +
    frame_bury 7
    b test_array_for_header@6

test_array_else_body@12:
    // tests/artifacts/Arrays/static_size.py:133
    // dy = point.y - last_point.y
    frame_dig 6
    frame_dig 3
    -
    b test_array_after_if_else@13

test_array_else_body@9:
    // tests/artifacts/Arrays/static_size.py:125
    // point = path[point_idx]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:129
    // dx = point.x.native - last_point.x.native
    extract_uint64
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:122
    // last_point = path[0]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:129
    // dx = point.x.native - last_point.x.native
    extract_uint64
    -
    frame_bury 2
    b test_array_after_if_else@10

test_array_after_for@14:
    // tests/artifacts/Arrays/static_size.py:42
    // return path_length(path)
    frame_dig 5
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_tuple(some_more.0: bytes, some_more.1: bytes) -> bytes:
test_extend_from_tuple:
    // tests/artifacts/Arrays/static_size.py:44-45
    // @arc4.abimethod()
    // def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
    proto 2 1
    // tests/artifacts/Arrays/static_size.py:47
    // arr.extend(some_more)
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/static_size.py:48
    // last = arr[-1]
    dup
    len
    pushint 16 // 16
    /
    dup
    intc_0 // 1
    -
    pushint 16 // 16
    *
    dig 2
    swap
    pushint 16 // 16
    extract3
    extract 0 16
    // tests/artifacts/Arrays/static_size.py:49
    // assert last == some_more[1]
    dup
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:50
    // result = arr.freeze()
    swap
    itob
    extract 6 2
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:51
    // assert result[-1] == last
    dup
    intc_1 // 0
    extract_uint16
    intc_0 // 1
    -
    dig 1
    extract 2 0
    swap
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: Index access is out of bounds
    uncover 2
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:52
    // return result
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_arc4_tuple(some_more: bytes) -> bytes:
test_extend_from_arc4_tuple:
    // tests/artifacts/Arrays/static_size.py:54-57
    // @arc4.abimethod()
    // def test_extend_from_arc4_tuple(
    //     self, some_more: arc4.Tuple[More, More]
    // ) -> ImmutableArray[More]:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:59
    // arr.extend(some_more)
    frame_dig -1
    pop
    // tests/artifacts/Arrays/static_size.py:60
    // return arr.freeze()
    pushbytes 0x0002
    frame_dig -1
    concat
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_bool_array(length: uint64) -> uint64:
test_bool_array:
    // tests/artifacts/Arrays/static_size.py:62-63
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> UInt64:
    proto 1 1
    bytec_2 // ""
    // tests/artifacts/Arrays/static_size.py:64
    // arr = Array[bool]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:67
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_0 // 1
    +
    intc_0 // 1

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:67
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/static_size.py:68
    // arr.append(i % 2 == 0)
    frame_dig 6
    dup
    pushint 2 // 2
    %
    !
    pushbytess 0x00 0x80 // 0x00, 0x80
    uncover 2
    select
    frame_dig 4
    swap
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:67
    // for i in urange(1, length + 1):
    intc_0 // 1
    +
    frame_bury 6
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:69
    // assert arr.length == length, "expected correct length"
    len
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:70
    // count = UInt64(0)
    intc_1 // 0
    frame_bury 1
    intc_1 // 0
    frame_bury 3

test_bool_array_for_header@5:
    // tests/artifacts/Arrays/static_size.py:71
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_bool_array_after_for@10
    frame_dig 4
    frame_dig 3
    intc_0 // 1
    extract3
    intc_1 // 0
    getbit
    frame_dig 1
    frame_bury 2
    // tests/artifacts/Arrays/static_size.py:72
    // if val:
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:73
    // count += 1
    frame_dig 1
    intc_0 // 1
    +
    frame_bury 2

test_bool_array_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_0 // 1
    +
    frame_bury 3
    b test_bool_array_for_header@5

test_bool_array_after_for@10:
    // tests/artifacts/Arrays/static_size.py:74
    // return count
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_conversion(length: uint64) -> bytes:
test_arc4_conversion:
    // tests/artifacts/Arrays/static_size.py:76-77
    // @arc4.abimethod()
    // def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
    proto 1 1
    bytec_2 // ""
    // tests/artifacts/Arrays/static_size.py:78
    // arr = Array[arc4.UInt64]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:81
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_0 // 1
    +
    intc_0 // 1

test_arc4_conversion_for_header@1:
    // tests/artifacts/Arrays/static_size.py:81
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_arc4_conversion_after_for@4
    // tests/artifacts/Arrays/static_size.py:82
    // arr.append(arc4.UInt64(i))
    frame_dig 6
    dup
    itob
    frame_dig 4
    swap
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:81
    // for i in urange(1, length + 1):
    intc_0 // 1
    +
    frame_bury 6
    b test_arc4_conversion_for_header@1

test_arc4_conversion_after_for@4:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:83
    // assert arr.length == length, "expected correct length"
    len
    intc_2 // 8
    /
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:84
    // count = UInt64(0)
    intc_1 // 0
    frame_bury 1
    intc_1 // 0
    frame_bury 3

test_arc4_conversion_for_header@5:
    // tests/artifacts/Arrays/static_size.py:85
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_arc4_conversion_after_for@10
    frame_dig 4
    frame_dig 3
    intc_2 // 8
    *
    intc_2 // 8
    extract3
    extract 0 8
    // tests/artifacts/Arrays/static_size.py:86
    // if val:
    bytec_2 // 0x
    b!=
    frame_dig 1
    frame_bury 2
    bz test_arc4_conversion_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:87
    // count += 1
    frame_dig 1
    intc_0 // 1
    +
    frame_bury 2

test_arc4_conversion_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_0 // 1
    +
    frame_bury 3
    b test_arc4_conversion_for_header@5

test_arc4_conversion_after_for@10:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:90
    // arc4_arr.extend(arr)
    dup
    len
    intc_2 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/static_size.py:92
    // return arc4_arr
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.sum_array(arc4_arr: bytes) -> uint64:
sum_array:
    // tests/artifacts/Arrays/static_size.py:94-95
    // @arc4.abimethod()
    // def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:97
    // arr.extend(arc4_arr)
    frame_dig -1
    extract 2 0
    dup
    // tests/artifacts/Arrays/static_size.py:99
    // total = UInt64(0)
    intc_1 // 0
    swap
    // tests/artifacts/Arrays/static_size.py:100
    // for item in arr:
    len
    intc_2 // 8
    /
    intc_1 // 0

sum_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:100
    // for item in arr:
    frame_dig 3
    frame_dig 2
    <
    bz sum_array_after_for@4
    frame_dig 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 8
    *
    intc_2 // 8
    extract3
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:101
    // total += item.native
    extract_uint64
    frame_dig 1
    +
    frame_bury 1
    intc_0 // 1
    +
    frame_bury 3
    b sum_array_for_header@1

sum_array_after_for@4:
    // tests/artifacts/Arrays/static_size.py:103
    // return total
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes:
xtra:
    // tests/artifacts/Arrays/static_size.py:107
    // self.count += 1
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_0 // 1
    +
    bytec_0 // "count"
    swap
    app_global_put
    // tests/artifacts/Arrays/static_size.py:109
    // a=Txn.num_app_args,
    txn NumAppArgs
    // tests/artifacts/Arrays/static_size.py:110
    // b=self.count,
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    // tests/artifacts/Arrays/static_size.py:111
    // c=Txn.sender,
    txn Sender
    // tests/artifacts/Arrays/static_size.py:112
    // d=self.more(),
    callsub more
    // tests/artifacts/Arrays/static_size.py:108-113
    // return Xtra(
    //     a=Txn.num_app_args,
    //     b=self.count,
    //     c=Txn.sender,
    //     d=self.more(),
    // )
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.more() -> bytes:
more:
    // tests/artifacts/Arrays/static_size.py:117
    // return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_0 // 1
    +
    itob
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    *
    itob
    concat
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.Arrays.static_size.StaticSizeContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1 8 16 144
    bytecblock 0x151f7c75 "count" 0x00 0x 0x0000
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/Arrays/static_size.py:39
    // self.count = UInt64(0)
    bytec_1 // "count"
    intc_0 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@12
    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 0x8d6e3a25 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64", method "test_arc4_bool()bool[]"
    txna ApplicationArgs 0
    match main_test_array_route@5 main_test_extend_from_tuple_route@6 main_test_extend_from_arc4_tuple_route@7 main_test_bool_array_route@8 main_test_arc4_conversion_route@9 main_sum_array_route@10 main_test_arc4_bool_route@11

main_after_if_else@14:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    intc_0 // 0
    return

main_test_arc4_bool_route@11:
    // tests/artifacts/Arrays/static_size.py:138
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_sum_array_route@10:
    // tests/artifacts/Arrays/static_size.py:112
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:112
    // @arc4.abimethod()
    callsub sum_array
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_arc4_conversion_route@9:
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    callsub test_arc4_conversion
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bool_array_route@8:
    // tests/artifacts/Arrays/static_size.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:75
    // @arc4.abimethod()
    callsub test_bool_array
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_extend_from_arc4_tuple_route@7:
    // tests/artifacts/Arrays/static_size.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:67
    // @arc4.abimethod()
    callsub test_extend_from_arc4_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_extend_from_tuple_route@6:
    // tests/artifacts/Arrays/static_size.py:57
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 16
    swap
    extract 16 16
    // tests/artifacts/Arrays/static_size.py:57
    // @arc4.abimethod()
    callsub test_extend_from_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_array_route@5:
    // tests/artifacts/Arrays/static_size.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/Arrays/static_size.py:41
    // @arc4.abimethod()
    callsub test_array
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_bare_routing@12:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@14
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_3 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    dup
    uncover 2
    uncover 3
    pushint 7 // 7
    +
    intc_2 // 8
    /
    dup
    cover 3
    swap
    pushint 7 // 7
    +
    intc_2 // 8
    /
    dup
    cover 3
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 7

dynamic_array_concat_bits_after_if_else@2:
    frame_dig 7
    frame_bury 4
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    intc_3 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_array(x1: bytes, y1: uint64, x2: bytes, y2: uint64) -> uint64:
test_array:
    // tests/artifacts/Arrays/static_size.py:41-42
    // @arc4.abimethod()
    // def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
    proto 4 1
    intc_0 // 0
    dup
    bytec_3 // ""
    dupn 5
    // tests/artifacts/Arrays/static_size.py:43
    // self.count = UInt64(0)
    bytec_1 // "count"
    intc_0 // 0
    app_global_put
    // tests/artifacts/Arrays/static_size.py:45
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:46
    // Point(x=x1, y=y1, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:47
    // Point(x=x2, y=y2, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:44-48
    // path = ReferenceArray(
    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //     Point(x=x1, y=y1, other=self.xtra()),
    //     Point(x=x2, y=y2, other=self.xtra()),
    // )
    uncover 14
    itob
    uncover 14
    itob
    concat
    uncover 13
    concat
    uncover 12
    concat
    dig 11
    len
    pushint 64 // 64
    <=
    assert // overflow
    pushint 64 // 64
    bzero
    uncover 12
    dig 1
    b|
    uncover 2
    swap
    concat
    pushbytes 0x00000000000000000000000000000000
    swap
    concat
    frame_dig -3
    itob
    frame_dig -4
    swap
    concat
    uncover 12
    itob
    uncover 12
    itob
    concat
    uncover 11
    concat
    uncover 10
    concat
    dig 9
    len
    pushint 64 // 64
    <=
    assert // overflow
    uncover 9
    dig 4
    b|
    concat
    concat
    concat
    frame_dig -1
    itob
    frame_dig -2
    swap
    concat
    uncover 7
    itob
    uncover 7
    itob
    concat
    uncover 6
    concat
    uncover 5
    concat
    dig 4
    len
    pushint 64 // 64
    <=
    assert // overflow
    uncover 4
    uncover 4
    b|
    concat
    concat
    concat
    // tests/artifacts/Arrays/static_size.py:49
    // for i in urange(3):
    intc_0 // 0

test_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:49
    // for i in urange(3):
    frame_dig 9
    pushint 3 // 3
    <
    bz test_array_after_for@4
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:50
    // assert path[i].other.b == i + 1
    frame_dig 9
    dup
    cover 2
    intc 4 // 144
    *
    intc 4 // 144
    extract3 // on error: index access is out of bounds
    extract 16 128
    dup
    intc_2 // 8
    extract_uint64
    swap
    extract 48 16
    dig 2
    intc_1 // 1
    +
    uncover 2
    dig 1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:51
    // assert path[i].other.d.foo == i + 2
    dig 1
    extract 0 8
    uncover 3
    pushint 2 // 2
    +
    itob
    b==
    assert
    // tests/artifacts/Arrays/static_size.py:52
    // assert path[i].other.d.bar == (i + 1) * (i + 1)
    swap
    extract 8 8
    dig 1
    dig 2
    *
    itob
    b==
    assert
    frame_bury 9
    b test_array_for_header@1

test_array_after_for@4:
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:54
    // Box(ImmutableArray[Point], key="a").value = path.freeze()
    dup
    len
    intc 4 // 144
    /
    dup
    frame_bury 2
    itob
    extract 6 2
    dig 1
    concat
    pushbytes "a"
    box_del
    pop
    pushbytes "a"
    swap
    box_put
    // tests/artifacts/Arrays/static_size.py:167
    // last_point = path[0]
    extract 0 144 // on error: index access is out of bounds
    dup
    frame_bury 0
    dup
    extract 0 8
    frame_bury 1
    intc_2 // 8
    extract_uint64
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:168
    // length = UInt64()
    intc_0 // 0
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:169
    // for point_idx in urange(1, path.length):
    intc_1 // 1
    frame_bury 7

test_array_for_header@6:
    // tests/artifacts/Arrays/static_size.py:169
    // for point_idx in urange(1, path.length):
    frame_dig 7
    frame_dig 2
    <
    bz test_array_after_for@14
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:170
    // point = path[point_idx]
    frame_dig 7
    intc 4 // 144
    *
    intc 4 // 144
    extract3 // on error: index access is out of bounds
    dupn 2
    extract 0 8
    swap
    intc_2 // 8
    extract_uint64
    frame_bury 6
    // tests/artifacts/Arrays/static_size.py:171
    // if point.x < last_point.x:
    frame_dig 1
    b<
    bz test_array_else_body@9
    // tests/artifacts/Arrays/static_size.py:172
    // dx = last_point.x.native - point.x.native
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:167
    // last_point = path[0]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:172
    // dx = last_point.x.native - point.x.native
    extract_uint64
    swap
    // tests/artifacts/Arrays/static_size.py:170
    // point = path[point_idx]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:172
    // dx = last_point.x.native - point.x.native
    extract_uint64
    -
    frame_bury 3

test_array_after_if_else@10:
    // tests/artifacts/Arrays/static_size.py:175
    // if point.y < last_point.y:
    frame_dig 6
    frame_dig 4
    <
    bz test_array_else_body@12
    // tests/artifacts/Arrays/static_size.py:176
    // dy = last_point.y - point.y
    frame_dig 4
    frame_dig 6
    -

test_array_after_if_else@13:
    // tests/artifacts/Arrays/static_size.py:179
    // length += op.sqrt(dx * dx + dy * dy)
    frame_dig 3
    dup
    *
    swap
    dup
    *
    +
    sqrt
    frame_dig 5
    +
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:169
    // for point_idx in urange(1, path.length):
    frame_dig 7
    intc_1 // 1
    +
    frame_bury 7
    b test_array_for_header@6

test_array_else_body@12:
    // tests/artifacts/Arrays/static_size.py:178
    // dy = point.y - last_point.y
    frame_dig 6
    frame_dig 4
    -
    b test_array_after_if_else@13

test_array_else_body@9:
    // tests/artifacts/Arrays/static_size.py:170
    // point = path[point_idx]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:174
    // dx = point.x.native - last_point.x.native
    extract_uint64
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:167
    // last_point = path[0]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:174
    // dx = point.x.native - last_point.x.native
    extract_uint64
    -
    frame_bury 3
    b test_array_after_if_else@10

test_array_after_for@14:
    // tests/artifacts/Arrays/static_size.py:55
    // return path_length(path)
    frame_dig 5
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_tuple(some_more.0: bytes, some_more.1: bytes) -> bytes:
test_extend_from_tuple:
    // tests/artifacts/Arrays/static_size.py:57-58
    // @arc4.abimethod()
    // def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
    proto 2 1
    // tests/artifacts/Arrays/static_size.py:60
    // arr.extend(some_more)
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/static_size.py:61
    // last = arr[-1]
    dup
    len
    intc_3 // 16
    /
    dup
    intc_1 // 1
    -
    intc_3 // 16
    *
    dig 2
    swap
    intc_3 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:62
    // assert last == some_more[1]
    dup
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:63
    // result = arr.freeze()
    swap
    itob
    extract 6 2
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:64
    // assert result[-1] == last
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 16
    *
    intc_3 // 16
    extract3 // on error: index access is out of bounds
    uncover 2
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:65
    // return result
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_arc4_tuple(some_more: bytes) -> bytes:
test_extend_from_arc4_tuple:
    // tests/artifacts/Arrays/static_size.py:67-70
    // @arc4.abimethod()
    // def test_extend_from_arc4_tuple(
    //     self, some_more: arc4.Tuple[More, More]
    // ) -> ImmutableArray[More]:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:72
    // arr.extend(some_more)
    frame_dig -1
    pop
    // tests/artifacts/Arrays/static_size.py:73
    // return arr.freeze()
    frame_dig -1
    len
    intc_3 // 16
    /
    itob
    extract 6 2
    frame_dig -1
    concat
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_bool_array(length: uint64) -> uint64:
test_bool_array:
    // tests/artifacts/Arrays/static_size.py:75-76
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> UInt64:
    proto 1 1
    bytec_3 // ""
    // tests/artifacts/Arrays/static_size.py:77
    // arr = ReferenceArray[bool]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:80
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_1 // 1
    +
    intc_1 // 1

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:80
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/static_size.py:81
    // arr.append(i % 2 == 0)
    frame_dig 6
    dup
    pushint 2 // 2
    %
    !
    frame_dig 4
    swap
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:80
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    frame_bury 6
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    frame_dig 4
    dupn 2
    // tests/artifacts/Arrays/static_size.py:82
    // assert arr.length == length, "expected correct length"
    len
    frame_dig -1
    ==
    assert // expected correct length
    dig 1
    // tests/artifacts/Arrays/static_size.py:85
    // arr2.extend(arr)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/static_size.py:86
    // assert arr2.length == length * 2, "expected correct length"
    len
    frame_dig -1
    pushint 2 // 2
    *
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:88
    // count = UInt64(0)
    intc_0 // 0
    frame_bury 1
    // tests/artifacts/Arrays/static_size.py:89
    // for val in arr:
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 3

test_bool_array_for_header@5:
    // tests/artifacts/Arrays/static_size.py:89
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_bool_array_after_for@10
    frame_dig 4
    frame_dig 3
    intc_1 // 1
    extract3 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    frame_dig 1
    frame_bury 2
    // tests/artifacts/Arrays/static_size.py:90
    // if val:
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:91
    // count += 1
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 2

test_bool_array_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_1 // 1
    +
    frame_bury 3
    b test_bool_array_for_header@5

test_bool_array_after_for@10:
    // tests/artifacts/Arrays/static_size.py:92
    // return count
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_conversion(length: uint64) -> bytes:
test_arc4_conversion:
    // tests/artifacts/Arrays/static_size.py:94-95
    // @arc4.abimethod()
    // def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
    proto 1 1
    bytec_3 // ""
    // tests/artifacts/Arrays/static_size.py:96
    // arr = ReferenceArray[arc4.UInt64]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:99
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_1 // 1
    +
    intc_1 // 1

test_arc4_conversion_for_header@1:
    // tests/artifacts/Arrays/static_size.py:99
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_arc4_conversion_after_for@4
    // tests/artifacts/Arrays/static_size.py:100
    // arr.append(arc4.UInt64(i))
    frame_dig 6
    dup
    itob
    frame_dig 4
    swap
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:99
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    frame_bury 6
    b test_arc4_conversion_for_header@1

test_arc4_conversion_after_for@4:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:101
    // assert arr.length == length, "expected correct length"
    len
    intc_2 // 8
    /
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:102
    // count = UInt64(0)
    intc_0 // 0
    frame_bury 1
    intc_0 // 0
    frame_bury 3

test_arc4_conversion_for_header@5:
    // tests/artifacts/Arrays/static_size.py:103
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_arc4_conversion_after_for@10
    frame_dig 4
    frame_dig 3
    intc_2 // 8
    *
    intc_2 // 8
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:104
    // if val:
    bytec_3 // 0x
    b!=
    frame_dig 1
    frame_bury 2
    bz test_arc4_conversion_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:105
    // count += 1
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 2

test_arc4_conversion_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_1 // 1
    +
    frame_bury 3
    b test_arc4_conversion_for_header@5

test_arc4_conversion_after_for@10:
    // tests/artifacts/Arrays/static_size.py:107
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    bytec 4 // 0x0000
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:108
    // arc4_arr.extend(arr)
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_2 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/static_size.py:110
    // return arc4_arr
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.sum_array(arc4_arr: bytes) -> uint64:
sum_array:
    // tests/artifacts/Arrays/static_size.py:112-113
    // @arc4.abimethod()
    // def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:115
    // arr.extend(arc4_arr)
    frame_dig -1
    extract 2 0
    dup
    // tests/artifacts/Arrays/static_size.py:117
    // total = UInt64(0)
    intc_0 // 0
    swap
    // tests/artifacts/Arrays/static_size.py:118
    // for item in arr:
    len
    intc_2 // 8
    /
    intc_0 // 0

sum_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:118
    // for item in arr:
    frame_dig 3
    frame_dig 2
    <
    bz sum_array_after_for@4
    frame_dig 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 8
    *
    // tests/artifacts/Arrays/static_size.py:119
    // total += item.native
    extract_uint64
    frame_dig 1
    +
    frame_bury 1
    intc_1 // 1
    +
    frame_bury 3
    b sum_array_for_header@1

sum_array_after_for@4:
    // tests/artifacts/Arrays/static_size.py:121
    // return total
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes, bytes:
xtra:
    // tests/artifacts/Arrays/static_size.py:125
    // self.count += 1
    intc_0 // 0
    bytec_1 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_1 // 1
    +
    bytec_1 // "count"
    dig 1
    app_global_put
    // tests/artifacts/Arrays/static_size.py:127
    // a=Txn.num_app_args,
    txn NumAppArgs
    // tests/artifacts/Arrays/static_size.py:129
    // c=Txn.sender,
    txn Sender
    // tests/artifacts/Arrays/static_size.py:130
    // d=self.more(),
    callsub more
    // tests/artifacts/Arrays/static_size.py:131
    // e=BigUInt(self.count),
    intc_0 // 0
    bytec_1 // "count"
    app_global_get_ex
    assert // check self.count exists
    itob
    // tests/artifacts/Arrays/static_size.py:126-132
    // return Xtra(
    //     a=Txn.num_app_args,
    //     b=self.count,
    //     c=Txn.sender,
    //     d=self.more(),
    //     e=BigUInt(self.count),
    // )
    uncover 3
    cover 4
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.more() -> bytes:
more:
    // tests/artifacts/Arrays/static_size.py:136
    // return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
    intc_0 // 0
    bytec_1 // "count"
    app_global_get_ex
    assert // check self.count exists
    dup
    intc_1 // 1
    +
    itob
    dig 1
    uncover 2
    *
    itob
    concat
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_bool() -> bytes:
test_arc4_bool:
    // tests/artifacts/Arrays/static_size.py:138-139
    // @arc4.abimethod()
    // def test_arc4_bool(self) -> ImmutableArray[arc4.Bool]:
    proto 0 1
    // tests/artifacts/Arrays/static_size.py:141
    // arr.append(arc4.Bool(Txn.sender == Txn.receiver))
    txn Sender
    txn Receiver
    ==
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    // tests/artifacts/Arrays/static_size.py:142
    // arr.append(arc4.Bool(Txn.sender != Txn.receiver))
    txn Sender
    txn Receiver
    !=
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat // on error: max array length exceeded
    dupn 2
    uncover 2
    // tests/artifacts/Arrays/static_size.py:145
    // dyn_arr.extend(arr)
    dup
    len
    // tests/artifacts/Arrays/static_size.py:144
    // dyn_arr = arc4.DynamicArray[arc4.Bool]()
    bytec 4 // 0x0000
    // tests/artifacts/Arrays/static_size.py:145
    // dyn_arr.extend(arr)
    cover 2
    intc_2 // 8
    callsub dynamic_array_concat_bits
    dup
    cover 2
    // tests/artifacts/Arrays/static_size.py:146
    // assert dyn_arr.length == 2, "expected correct length"
    dup
    intc_0 // 0
    extract_uint16
    dup
    cover 3
    dup
    pushint 2 // 2
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:147
    // assert dyn_arr.bytes.length == 3, "expected 3 bytes"
    dig 1
    len
    pushint 3 // 3
    ==
    assert // expected 3 bytes
    // tests/artifacts/Arrays/static_size.py:148
    // assert dyn_arr[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
    dup
    assert // index access is out of bounds
    dig 1
    intc_3 // 16
    getbit
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 0
    // tests/artifacts/Arrays/static_size.py:149
    // assert dyn_arr[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
    intc_1 // 1
    >
    assert // index access is out of bounds
    pushint 17 // 17
    getbit
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 1
    intc_0 // 0

test_arc4_bool_for_header@1:
    // tests/artifacts/Arrays/static_size.py:152-154
    // # note: not supported currently
    // # arr2.extend(dyn_array)
    // for b in dyn_arr:
    frame_dig 4
    frame_dig 2
    <
    bz test_arc4_bool_after_for@4
    frame_dig 4
    dup
    intc_3 // 16
    +
    frame_dig 1
    swap
    getbit
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 3
    // tests/artifacts/Arrays/static_size.py:155
    // arr2.append(b)
    swap
    concat // on error: max array length exceeded
    frame_bury 3
    intc_1 // 1
    +
    frame_bury 4
    b test_arc4_bool_for_header@1

test_arc4_bool_after_for@4:
    frame_dig 3
    // tests/artifacts/Arrays/static_size.py:156
    // assert arr2.length == 4, "expected correct length"
    dup
    len
    pushint 4 // 4
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:157
    // assert arr2[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
    dup
    extract 0 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 0
    // tests/artifacts/Arrays/static_size.py:158
    // assert arr2[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
    dup
    extract 1 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 1
    // tests/artifacts/Arrays/static_size.py:159
    // assert arr2[2] == (Txn.sender == Txn.receiver), "expected correct value at 2"
    dup
    extract 2 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 2
    // tests/artifacts/Arrays/static_size.py:160
    // assert arr2[3] == (Txn.sender != Txn.receiver), "expected correct value at 3"
    extract 3 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 3
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:162
    // return arr.freeze()
    dup
    len
    bytec 4 // 0x0000
    cover 2
    intc_2 // 8
    callsub dynamic_array_concat_bits
    frame_bury 0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
@@ -152,6 +157,14 @@
                 "returns": {
                     "type": "uint64"
                 }
+            },
+            {
+                "name": "test_arc4_bool",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "bool[]"
+                }
             }
         ],
         "networks": {}
diff --git a/tests/artifacts/Arrays/data/StaticSizeContract.arc56.json b/tests/artifacts/Arrays/data/StaticSizeContract.arc56.json
index ac3d6409..3120e6a4 100644
--- a/tests/artifacts/Arrays/data/StaticSizeContract.arc56.json
+++ b/tests/artifacts/Arrays/data/StaticSizeContract.arc56.json
@@ -139,6 +139,22 @@
             "readonly": false,
             "events": [],
             "recommendations": {}
+        },
+        {
+            "name": "test_arc4_bool",
+            "args": [],
+            "returns": {
+                "type": "bool[]"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
         }
     ],
     "arcs": [
@@ -185,65 +201,120 @@
             "sourceInfo": [
                 {
                     "pc": [
-                        178,
-                        182,
-                        371,
-                        382,
-                        602
-                    ],
-                    "errorMessage": "Index access is out of bounds"
-                },
-                {
-                    "pc": [
-                        90,
-                        110,
-                        130,
-                        151,
-                        170,
-                        197
+                        102,
+                        118,
+                        138,
+                        158,
+                        179,
+                        198,
+                        225
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        233
+                        261
                     ],
                     "errorMessage": "can only call when creating"
                 },
                 {
                     "pc": [
-                        93,
-                        113,
-                        133,
-                        154,
-                        173,
-                        200
+                        105,
+                        121,
+                        141,
+                        161,
+                        182,
+                        201,
+                        228
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        905,
-                        916,
-                        926,
-                        933,
-                        937
+                        1125,
+                        1142,
+                        1152
                     ],
                     "errorMessage": "check self.count exists"
                 },
                 {
                     "pc": [
-                        679,
-                        780
+                        1223
+                    ],
+                    "errorMessage": "expected 3 bytes"
+                },
+                {
+                    "pc": [
+                        885,
+                        896,
+                        1000,
+                        1216,
+                        1307
                     ],
                     "errorMessage": "expected correct length"
                 },
                 {
                     "pc": [
-                        660,
-                        759
+                        1243,
+                        1320
+                    ],
+                    "errorMessage": "expected correct value at 0"
+                },
+                {
+                    "pc": [
+                        1263,
+                        1333
+                    ],
+                    "errorMessage": "expected correct value at 1"
+                },
+                {
+                    "pc": [
+                        1346
+                    ],
+                    "errorMessage": "expected correct value at 2"
+                },
+                {
+                    "pc": [
+                        1358
+                    ],
+                    "errorMessage": "expected correct value at 3"
+                },
+                {
+                    "pc": [
+                        554,
+                        632,
+                        671,
+                        780,
+                        808,
+                        919,
+                        1022,
+                        1225,
+                        1246,
+                        1309,
+                        1322,
+                        1335,
+                        1347
+                    ],
+                    "errorMessage": "index access is out of bounds"
+                },
+                {
+                    "pc": [
+                        867,
+                        888,
+                        979,
+                        1055,
+                        1188,
+                        1290
                     ],
                     "errorMessage": "max array length exceeded"
+                },
+                {
+                    "pc": [
+                        430,
+                        489,
+                        524
+                    ],
+                    "errorMessage": "overflow"
                 }
             ],
             "pcOffsetMethod": "none"
@@ -254,19 +325,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.Arrays.static_size.StaticSizeContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0 8 80
    bytecblock "count" 0x151f7c75 0x "a"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/Arrays/static_size.py:26
    // self.count = UInt64(0)
    bytec_0 // "count"
    intc_1 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@11
    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64"
    txna ApplicationArgs 0
    match main_test_array_route@5 main_test_extend_from_tuple_route@6 main_test_extend_from_arc4_tuple_route@7 main_test_bool_array_route@8 main_test_arc4_conversion_route@9 main_sum_array_route@10

main_after_if_else@13:
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    intc_1 // 0
    return

main_sum_array_route@10:
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    callsub sum_array
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_arc4_conversion_route@9:
    // tests/artifacts/Arrays/static_size.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:76
    // @arc4.abimethod()
    callsub test_arc4_conversion
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_bool_array_route@8:
    // tests/artifacts/Arrays/static_size.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:62
    // @arc4.abimethod()
    callsub test_bool_array
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_extend_from_arc4_tuple_route@7:
    // tests/artifacts/Arrays/static_size.py:54
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:54
    // @arc4.abimethod()
    callsub test_extend_from_arc4_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_extend_from_tuple_route@6:
    // tests/artifacts/Arrays/static_size.py:44
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 16 // on error: Index access is out of bounds
    swap
    extract 16 16 // on error: Index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:44
    // @arc4.abimethod()
    callsub test_extend_from_tuple
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_test_array_route@5:
    // tests/artifacts/Arrays/static_size.py:28
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/Arrays/static_size.py:28
    // @arc4.abimethod()
    callsub test_array
    itob
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@11:
    // tests/artifacts/Arrays/static_size.py:24
    // class StaticSizeContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@13
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_array(x1: bytes, y1: uint64, x2: bytes, y2: uint64) -> uint64:
test_array:
    // tests/artifacts/Arrays/static_size.py:28-29
    // @arc4.abimethod()
    // def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
    proto 4 1
    intc_1 // 0
    dup
    bytec_2 // ""
    dupn 5
    // tests/artifacts/Arrays/static_size.py:30
    // self.count = UInt64(0)
    bytec_0 // "count"
    intc_1 // 0
    app_global_put
    // tests/artifacts/Arrays/static_size.py:32
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:33
    // Point(x=x1, y=y1, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:34
    // Point(x=x2, y=y2, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:32
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    uncover 11
    itob
    pushbytes 0x00000000000000000000000000000000
    swap
    concat
    uncover 11
    itob
    concat
    uncover 10
    concat
    uncover 9
    concat
    // tests/artifacts/Arrays/static_size.py:33
    // Point(x=x1, y=y1, other=self.xtra()),
    frame_dig -3
    itob
    frame_dig -4
    swap
    concat
    uncover 9
    itob
    concat
    uncover 8
    itob
    concat
    uncover 7
    concat
    uncover 6
    concat
    // tests/artifacts/Arrays/static_size.py:31-35
    // path = Array(
    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //     Point(x=x1, y=y1, other=self.xtra()),
    //     Point(x=x2, y=y2, other=self.xtra()),
    // )
    concat
    // tests/artifacts/Arrays/static_size.py:34
    // Point(x=x2, y=y2, other=self.xtra()),
    frame_dig -1
    itob
    frame_dig -2
    swap
    concat
    uncover 5
    itob
    concat
    uncover 4
    itob
    concat
    uncover 3
    concat
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:31-35
    // path = Array(
    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //     Point(x=x1, y=y1, other=self.xtra()),
    //     Point(x=x2, y=y2, other=self.xtra()),
    // )
    concat
    // tests/artifacts/Arrays/static_size.py:36
    // for i in urange(3):
    intc_1 // 0

test_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:36
    // for i in urange(3):
    frame_dig 9
    pushint 3 // 3
    <
    bz test_array_after_for@4
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:37
    // assert path[i].other.b == i + 1
    frame_dig 9
    dup
    cover 2
    intc_3 // 80
    *
    intc_3 // 80
    extract3
    dup
    pushint 24 // 24
    extract_uint64
    dig 2
    intc_0 // 1
    +
    swap
    dig 1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:38
    // assert path[i].other.d.foo == i + 2
    swap
    extract 64 16
    dup
    extract 0 8 // on error: Index access is out of bounds
    uncover 3
    pushint 2 // 2
    +
    itob
    b==
    assert
    // tests/artifacts/Arrays/static_size.py:39
    // assert path[i].other.d.bar == (i + 1) * (i + 1)
    extract 8 8 // on error: Index access is out of bounds
    dig 1
    dig 2
    *
    itob
    b==
    assert
    frame_bury 9
    b test_array_for_header@1

test_array_after_for@4:
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:41
    // Box(ImmutableArray[Point], key="a").value = path.freeze()
    dup
    len
    intc_3 // 80
    /
    dup
    frame_bury 4
    itob
    extract 6 2
    dig 1
    concat
    bytec_3 // "a"
    box_del
    pop
    bytec_3 // "a"
    swap
    box_put
    // tests/artifacts/Arrays/static_size.py:122
    // last_point = path[0]
    extract 0 80
    dup
    frame_bury 0
    dup
    extract 0 8
    frame_bury 1
    intc_2 // 8
    extract_uint64
    frame_bury 3
    // tests/artifacts/Arrays/static_size.py:123
    // length = UInt64()
    intc_1 // 0
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:124
    // for point_idx in urange(1, path.length):
    intc_0 // 1
    frame_bury 7

test_array_for_header@6:
    // tests/artifacts/Arrays/static_size.py:124
    // for point_idx in urange(1, path.length):
    frame_dig 7
    frame_dig 4
    <
    bz test_array_after_for@14
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:125
    // point = path[point_idx]
    frame_dig 7
    intc_3 // 80
    *
    intc_3 // 80
    extract3
    dupn 2
    extract 0 8
    swap
    intc_2 // 8
    extract_uint64
    frame_bury 6
    // tests/artifacts/Arrays/static_size.py:126
    // if point.x < last_point.x:
    frame_dig 1
    b<
    bz test_array_else_body@9
    // tests/artifacts/Arrays/static_size.py:127
    // dx = last_point.x.native - point.x.native
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:122
    // last_point = path[0]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:127
    // dx = last_point.x.native - point.x.native
    extract_uint64
    swap
    // tests/artifacts/Arrays/static_size.py:125
    // point = path[point_idx]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:127
    // dx = last_point.x.native - point.x.native
    extract_uint64
    -
    frame_bury 2

test_array_after_if_else@10:
    // tests/artifacts/Arrays/static_size.py:130
    // if point.y < last_point.y:
    frame_dig 6
    frame_dig 3
    <
    bz test_array_else_body@12
    // tests/artifacts/Arrays/static_size.py:131
    // dy = last_point.y - point.y
    frame_dig 3
    frame_dig 6
    -

test_array_after_if_else@13:
    // tests/artifacts/Arrays/static_size.py:134
    // length += op.sqrt(dx * dx + dy * dy)
    frame_dig 2
    dup
    *
    swap
    dup
    *
    +
    sqrt
    frame_dig 5
    +
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:124
    // for point_idx in urange(1, path.length):
    frame_dig 7
    intc_0 // 1
    +
    frame_bury 7
    b test_array_for_header@6

test_array_else_body@12:
    // tests/artifacts/Arrays/static_size.py:133
    // dy = point.y - last_point.y
    frame_dig 6
    frame_dig 3
    -
    b test_array_after_if_else@13

test_array_else_body@9:
    // tests/artifacts/Arrays/static_size.py:125
    // point = path[point_idx]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:129
    // dx = point.x.native - last_point.x.native
    extract_uint64
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:122
    // last_point = path[0]
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:129
    // dx = point.x.native - last_point.x.native
    extract_uint64
    -
    frame_bury 2
    b test_array_after_if_else@10

test_array_after_for@14:
    // tests/artifacts/Arrays/static_size.py:42
    // return path_length(path)
    frame_dig 5
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_tuple(some_more.0: bytes, some_more.1: bytes) -> bytes:
test_extend_from_tuple:
    // tests/artifacts/Arrays/static_size.py:44-45
    // @arc4.abimethod()
    // def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
    proto 2 1
    // tests/artifacts/Arrays/static_size.py:47
    // arr.extend(some_more)
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/static_size.py:48
    // last = arr[-1]
    dup
    len
    pushint 16 // 16
    /
    dup
    intc_0 // 1
    -
    pushint 16 // 16
    *
    dig 2
    swap
    pushint 16 // 16
    extract3
    extract 0 16
    // tests/artifacts/Arrays/static_size.py:49
    // assert last == some_more[1]
    dup
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:50
    // result = arr.freeze()
    swap
    itob
    extract 6 2
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:51
    // assert result[-1] == last
    dup
    intc_1 // 0
    extract_uint16
    intc_0 // 1
    -
    dig 1
    extract 2 0
    swap
    pushint 16 // 16
    *
    pushint 16 // 16
    extract3 // on error: Index access is out of bounds
    uncover 2
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:52
    // return result
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_arc4_tuple(some_more: bytes) -> bytes:
test_extend_from_arc4_tuple:
    // tests/artifacts/Arrays/static_size.py:54-57
    // @arc4.abimethod()
    // def test_extend_from_arc4_tuple(
    //     self, some_more: arc4.Tuple[More, More]
    // ) -> ImmutableArray[More]:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:59
    // arr.extend(some_more)
    frame_dig -1
    pop
    // tests/artifacts/Arrays/static_size.py:60
    // return arr.freeze()
    pushbytes 0x0002
    frame_dig -1
    concat
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_bool_array(length: uint64) -> uint64:
test_bool_array:
    // tests/artifacts/Arrays/static_size.py:62-63
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> UInt64:
    proto 1 1
    bytec_2 // ""
    // tests/artifacts/Arrays/static_size.py:64
    // arr = Array[bool]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:67
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_0 // 1
    +
    intc_0 // 1

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:67
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/static_size.py:68
    // arr.append(i % 2 == 0)
    frame_dig 6
    dup
    pushint 2 // 2
    %
    !
    pushbytess 0x00 0x80 // 0x00, 0x80
    uncover 2
    select
    frame_dig 4
    swap
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:67
    // for i in urange(1, length + 1):
    intc_0 // 1
    +
    frame_bury 6
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:69
    // assert arr.length == length, "expected correct length"
    len
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:70
    // count = UInt64(0)
    intc_1 // 0
    frame_bury 1
    intc_1 // 0
    frame_bury 3

test_bool_array_for_header@5:
    // tests/artifacts/Arrays/static_size.py:71
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_bool_array_after_for@10
    frame_dig 4
    frame_dig 3
    intc_0 // 1
    extract3
    intc_1 // 0
    getbit
    frame_dig 1
    frame_bury 2
    // tests/artifacts/Arrays/static_size.py:72
    // if val:
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:73
    // count += 1
    frame_dig 1
    intc_0 // 1
    +
    frame_bury 2

test_bool_array_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_0 // 1
    +
    frame_bury 3
    b test_bool_array_for_header@5

test_bool_array_after_for@10:
    // tests/artifacts/Arrays/static_size.py:74
    // return count
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_conversion(length: uint64) -> bytes:
test_arc4_conversion:
    // tests/artifacts/Arrays/static_size.py:76-77
    // @arc4.abimethod()
    // def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
    proto 1 1
    bytec_2 // ""
    // tests/artifacts/Arrays/static_size.py:78
    // arr = Array[arc4.UInt64]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:81
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_0 // 1
    +
    intc_0 // 1

test_arc4_conversion_for_header@1:
    // tests/artifacts/Arrays/static_size.py:81
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_arc4_conversion_after_for@4
    // tests/artifacts/Arrays/static_size.py:82
    // arr.append(arc4.UInt64(i))
    frame_dig 6
    dup
    itob
    frame_dig 4
    swap
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:81
    // for i in urange(1, length + 1):
    intc_0 // 1
    +
    frame_bury 6
    b test_arc4_conversion_for_header@1

test_arc4_conversion_after_for@4:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:83
    // assert arr.length == length, "expected correct length"
    len
    intc_2 // 8
    /
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:84
    // count = UInt64(0)
    intc_1 // 0
    frame_bury 1
    intc_1 // 0
    frame_bury 3

test_arc4_conversion_for_header@5:
    // tests/artifacts/Arrays/static_size.py:85
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_arc4_conversion_after_for@10
    frame_dig 4
    frame_dig 3
    intc_2 // 8
    *
    intc_2 // 8
    extract3
    extract 0 8
    // tests/artifacts/Arrays/static_size.py:86
    // if val:
    bytec_2 // 0x
    b!=
    frame_dig 1
    frame_bury 2
    bz test_arc4_conversion_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:87
    // count += 1
    frame_dig 1
    intc_0 // 1
    +
    frame_bury 2

test_arc4_conversion_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_0 // 1
    +
    frame_bury 3
    b test_arc4_conversion_for_header@5

test_arc4_conversion_after_for@10:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:90
    // arc4_arr.extend(arr)
    dup
    len
    intc_2 // 8
    /
    itob
    extract 6 2
    swap
    concat
    // tests/artifacts/Arrays/static_size.py:92
    // return arc4_arr
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.sum_array(arc4_arr: bytes) -> uint64:
sum_array:
    // tests/artifacts/Arrays/static_size.py:94-95
    // @arc4.abimethod()
    // def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:97
    // arr.extend(arc4_arr)
    frame_dig -1
    extract 2 0
    dup
    // tests/artifacts/Arrays/static_size.py:99
    // total = UInt64(0)
    intc_1 // 0
    swap
    // tests/artifacts/Arrays/static_size.py:100
    // for item in arr:
    len
    intc_2 // 8
    /
    intc_1 // 0

sum_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:100
    // for item in arr:
    frame_dig 3
    frame_dig 2
    <
    bz sum_array_after_for@4
    frame_dig 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 8
    *
    intc_2 // 8
    extract3
    intc_1 // 0
    // tests/artifacts/Arrays/static_size.py:101
    // total += item.native
    extract_uint64
    frame_dig 1
    +
    frame_bury 1
    intc_0 // 1
    +
    frame_bury 3
    b sum_array_for_header@1

sum_array_after_for@4:
    // tests/artifacts/Arrays/static_size.py:103
    // return total
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes:
xtra:
    // tests/artifacts/Arrays/static_size.py:107
    // self.count += 1
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_0 // 1
    +
    bytec_0 // "count"
    swap
    app_global_put
    // tests/artifacts/Arrays/static_size.py:109
    // a=Txn.num_app_args,
    txn NumAppArgs
    // tests/artifacts/Arrays/static_size.py:110
    // b=self.count,
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    // tests/artifacts/Arrays/static_size.py:111
    // c=Txn.sender,
    txn Sender
    // tests/artifacts/Arrays/static_size.py:112
    // d=self.more(),
    callsub more
    // tests/artifacts/Arrays/static_size.py:108-113
    // return Xtra(
    //     a=Txn.num_app_args,
    //     b=self.count,
    //     c=Txn.sender,
    //     d=self.more(),
    // )
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.more() -> bytes:
more:
    // tests/artifacts/Arrays/static_size.py:117
    // return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_0 // 1
    +
    itob
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_1 // 0
    bytec_0 // "count"
    app_global_get_ex
    assert // check self.count exists
    *
    itob
    concat
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.Arrays.static_size.StaticSizeContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1 8 16 144
    bytecblock 0x151f7c75 "count" 0x00 0x 0x0000
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/Arrays/static_size.py:39
    // self.count = UInt64(0)
    bytec_1 // "count"
    intc_0 // 0
    app_global_put

main_after_if_else@2:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@12
    pushbytess 0x28d7c1b8 0xfa9cb973 0x6039a240 0xf8fd68a7 0x1f028db1 0x096b3a59 0x8d6e3a25 // method "test_array(uint64,uint64,uint64,uint64)uint64", method "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]", method "test_bool_array(uint64)uint64", method "test_arc4_conversion(uint64)uint64[]", method "sum_array(uint64[])uint64", method "test_arc4_bool()bool[]"
    txna ApplicationArgs 0
    match main_test_array_route@5 main_test_extend_from_tuple_route@6 main_test_extend_from_arc4_tuple_route@7 main_test_bool_array_route@8 main_test_arc4_conversion_route@9 main_sum_array_route@10 main_test_arc4_bool_route@11

main_after_if_else@14:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    intc_0 // 0
    return

main_test_arc4_bool_route@11:
    // tests/artifacts/Arrays/static_size.py:138
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub test_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_sum_array_route@10:
    // tests/artifacts/Arrays/static_size.py:112
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:112
    // @arc4.abimethod()
    callsub sum_array
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_arc4_conversion_route@9:
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:94
    // @arc4.abimethod()
    callsub test_arc4_conversion
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_bool_array_route@8:
    // tests/artifacts/Arrays/static_size.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/Arrays/static_size.py:75
    // @arc4.abimethod()
    callsub test_bool_array
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_extend_from_arc4_tuple_route@7:
    // tests/artifacts/Arrays/static_size.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arrays/static_size.py:67
    // @arc4.abimethod()
    callsub test_extend_from_arc4_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_extend_from_tuple_route@6:
    // tests/artifacts/Arrays/static_size.py:57
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    dup
    extract 0 16
    swap
    extract 16 16
    // tests/artifacts/Arrays/static_size.py:57
    // @arc4.abimethod()
    callsub test_extend_from_tuple
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_test_array_route@5:
    // tests/artifacts/Arrays/static_size.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/Arrays/static_size.py:41
    // @arc4.abimethod()
    callsub test_array
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_bare_routing@12:
    // tests/artifacts/Arrays/static_size.py:37
    // class StaticSizeContract(arc4.ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@14
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_concat_bits(array: bytes, new_items_bytes: bytes, new_items_count: uint64, read_step: uint64) -> bytes:
dynamic_array_concat_bits:
    proto 4 1
    bytec_3 // ""
    dupn 2
    frame_dig -4
    intc_0 // 0
    extract_uint16
    dupn 2
    frame_dig -2
    +
    dup
    itob
    extract 6 0
    frame_dig -4
    swap
    replace2 0
    dup
    uncover 2
    uncover 3
    pushint 7 // 7
    +
    intc_2 // 8
    /
    dup
    cover 3
    swap
    pushint 7 // 7
    +
    intc_2 // 8
    /
    dup
    cover 3
    <
    bz dynamic_array_concat_bits_after_if_else@2
    frame_dig 6
    frame_dig 5
    -
    bzero
    frame_dig 4
    swap
    concat
    frame_bury 7

dynamic_array_concat_bits_after_if_else@2:
    frame_dig 7
    frame_bury 4
    intc_0 // 0
    frame_bury 0
    frame_dig 3
    intc_3 // 16
    +
    dup
    frame_bury 2
    frame_dig -2
    +
    frame_bury 1

dynamic_array_concat_bits_while_top@3:
    frame_dig 2
    frame_dig 1
    <
    bz dynamic_array_concat_bits_after_while@5
    frame_dig -3
    frame_dig 0
    dup
    cover 2
    getbit
    frame_dig 4
    frame_dig 2
    dup
    cover 3
    uncover 2
    setbit
    frame_bury 4
    intc_1 // 1
    +
    frame_bury 2
    frame_dig -1
    +
    frame_bury 0
    b dynamic_array_concat_bits_while_top@3

dynamic_array_concat_bits_after_while@5:
    frame_dig 4
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_array(x1: bytes, y1: uint64, x2: bytes, y2: uint64) -> uint64:
test_array:
    // tests/artifacts/Arrays/static_size.py:41-42
    // @arc4.abimethod()
    // def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
    proto 4 1
    intc_0 // 0
    dup
    bytec_3 // ""
    dupn 5
    // tests/artifacts/Arrays/static_size.py:43
    // self.count = UInt64(0)
    bytec_1 // "count"
    intc_0 // 0
    app_global_put
    // tests/artifacts/Arrays/static_size.py:45
    // Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:46
    // Point(x=x1, y=y1, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:47
    // Point(x=x2, y=y2, other=self.xtra()),
    callsub xtra
    // tests/artifacts/Arrays/static_size.py:44-48
    // path = ReferenceArray(
    //     Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
    //     Point(x=x1, y=y1, other=self.xtra()),
    //     Point(x=x2, y=y2, other=self.xtra()),
    // )
    uncover 14
    itob
    uncover 14
    itob
    concat
    uncover 13
    concat
    uncover 12
    concat
    dig 11
    len
    pushint 64 // 64
    <=
    assert // overflow
    pushint 64 // 64
    bzero
    uncover 12
    dig 1
    b|
    uncover 2
    swap
    concat
    pushbytes 0x00000000000000000000000000000000
    swap
    concat
    frame_dig -3
    itob
    frame_dig -4
    swap
    concat
    uncover 12
    itob
    uncover 12
    itob
    concat
    uncover 11
    concat
    uncover 10
    concat
    dig 9
    len
    pushint 64 // 64
    <=
    assert // overflow
    uncover 9
    dig 4
    b|
    concat
    concat
    concat
    frame_dig -1
    itob
    frame_dig -2
    swap
    concat
    uncover 7
    itob
    uncover 7
    itob
    concat
    uncover 6
    concat
    uncover 5
    concat
    dig 4
    len
    pushint 64 // 64
    <=
    assert // overflow
    uncover 4
    uncover 4
    b|
    concat
    concat
    concat
    // tests/artifacts/Arrays/static_size.py:49
    // for i in urange(3):
    intc_0 // 0

test_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:49
    // for i in urange(3):
    frame_dig 9
    pushint 3 // 3
    <
    bz test_array_after_for@4
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:50
    // assert path[i].other.b == i + 1
    frame_dig 9
    dup
    cover 2
    intc 4 // 144
    *
    intc 4 // 144
    extract3 // on error: index access is out of bounds
    extract 16 128
    dup
    intc_2 // 8
    extract_uint64
    swap
    extract 48 16
    dig 2
    intc_1 // 1
    +
    uncover 2
    dig 1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:51
    // assert path[i].other.d.foo == i + 2
    dig 1
    extract 0 8
    uncover 3
    pushint 2 // 2
    +
    itob
    b==
    assert
    // tests/artifacts/Arrays/static_size.py:52
    // assert path[i].other.d.bar == (i + 1) * (i + 1)
    swap
    extract 8 8
    dig 1
    dig 2
    *
    itob
    b==
    assert
    frame_bury 9
    b test_array_for_header@1

test_array_after_for@4:
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:54
    // Box(ImmutableArray[Point], key="a").value = path.freeze()
    dup
    len
    intc 4 // 144
    /
    dup
    frame_bury 2
    itob
    extract 6 2
    dig 1
    concat
    pushbytes "a"
    box_del
    pop
    pushbytes "a"
    swap
    box_put
    // tests/artifacts/Arrays/static_size.py:167
    // last_point = path[0]
    extract 0 144 // on error: index access is out of bounds
    dup
    frame_bury 0
    dup
    extract 0 8
    frame_bury 1
    intc_2 // 8
    extract_uint64
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:168
    // length = UInt64()
    intc_0 // 0
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:169
    // for point_idx in urange(1, path.length):
    intc_1 // 1
    frame_bury 7

test_array_for_header@6:
    // tests/artifacts/Arrays/static_size.py:169
    // for point_idx in urange(1, path.length):
    frame_dig 7
    frame_dig 2
    <
    bz test_array_after_for@14
    frame_dig 8
    // tests/artifacts/Arrays/static_size.py:170
    // point = path[point_idx]
    frame_dig 7
    intc 4 // 144
    *
    intc 4 // 144
    extract3 // on error: index access is out of bounds
    dupn 2
    extract 0 8
    swap
    intc_2 // 8
    extract_uint64
    frame_bury 6
    // tests/artifacts/Arrays/static_size.py:171
    // if point.x < last_point.x:
    frame_dig 1
    b<
    bz test_array_else_body@9
    // tests/artifacts/Arrays/static_size.py:172
    // dx = last_point.x.native - point.x.native
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:167
    // last_point = path[0]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:172
    // dx = last_point.x.native - point.x.native
    extract_uint64
    swap
    // tests/artifacts/Arrays/static_size.py:170
    // point = path[point_idx]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:172
    // dx = last_point.x.native - point.x.native
    extract_uint64
    -
    frame_bury 3

test_array_after_if_else@10:
    // tests/artifacts/Arrays/static_size.py:175
    // if point.y < last_point.y:
    frame_dig 6
    frame_dig 4
    <
    bz test_array_else_body@12
    // tests/artifacts/Arrays/static_size.py:176
    // dy = last_point.y - point.y
    frame_dig 4
    frame_dig 6
    -

test_array_after_if_else@13:
    // tests/artifacts/Arrays/static_size.py:179
    // length += op.sqrt(dx * dx + dy * dy)
    frame_dig 3
    dup
    *
    swap
    dup
    *
    +
    sqrt
    frame_dig 5
    +
    frame_bury 5
    // tests/artifacts/Arrays/static_size.py:169
    // for point_idx in urange(1, path.length):
    frame_dig 7
    intc_1 // 1
    +
    frame_bury 7
    b test_array_for_header@6

test_array_else_body@12:
    // tests/artifacts/Arrays/static_size.py:178
    // dy = point.y - last_point.y
    frame_dig 6
    frame_dig 4
    -
    b test_array_after_if_else@13

test_array_else_body@9:
    // tests/artifacts/Arrays/static_size.py:170
    // point = path[point_idx]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:174
    // dx = point.x.native - last_point.x.native
    extract_uint64
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:167
    // last_point = path[0]
    intc_0 // 0
    // tests/artifacts/Arrays/static_size.py:174
    // dx = point.x.native - last_point.x.native
    extract_uint64
    -
    frame_bury 3
    b test_array_after_if_else@10

test_array_after_for@14:
    // tests/artifacts/Arrays/static_size.py:55
    // return path_length(path)
    frame_dig 5
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_tuple(some_more.0: bytes, some_more.1: bytes) -> bytes:
test_extend_from_tuple:
    // tests/artifacts/Arrays/static_size.py:57-58
    // @arc4.abimethod()
    // def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
    proto 2 1
    // tests/artifacts/Arrays/static_size.py:60
    // arr.extend(some_more)
    frame_dig -2
    frame_dig -1
    concat
    // tests/artifacts/Arrays/static_size.py:61
    // last = arr[-1]
    dup
    len
    intc_3 // 16
    /
    dup
    intc_1 // 1
    -
    intc_3 // 16
    *
    dig 2
    swap
    intc_3 // 16
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:62
    // assert last == some_more[1]
    dup
    frame_dig -1
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:63
    // result = arr.freeze()
    swap
    itob
    extract 6 2
    uncover 2
    concat
    // tests/artifacts/Arrays/static_size.py:64
    // assert result[-1] == last
    dup
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    -
    dig 1
    extract 2 0
    swap
    intc_3 // 16
    *
    intc_3 // 16
    extract3 // on error: index access is out of bounds
    uncover 2
    ==
    assert
    // tests/artifacts/Arrays/static_size.py:65
    // return result
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_extend_from_arc4_tuple(some_more: bytes) -> bytes:
test_extend_from_arc4_tuple:
    // tests/artifacts/Arrays/static_size.py:67-70
    // @arc4.abimethod()
    // def test_extend_from_arc4_tuple(
    //     self, some_more: arc4.Tuple[More, More]
    // ) -> ImmutableArray[More]:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:72
    // arr.extend(some_more)
    frame_dig -1
    pop
    // tests/artifacts/Arrays/static_size.py:73
    // return arr.freeze()
    frame_dig -1
    len
    intc_3 // 16
    /
    itob
    extract 6 2
    frame_dig -1
    concat
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_bool_array(length: uint64) -> uint64:
test_bool_array:
    // tests/artifacts/Arrays/static_size.py:75-76
    // @arc4.abimethod()
    // def test_bool_array(self, length: UInt64) -> UInt64:
    proto 1 1
    bytec_3 // ""
    // tests/artifacts/Arrays/static_size.py:77
    // arr = ReferenceArray[bool]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:80
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_1 // 1
    +
    intc_1 // 1

test_bool_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:80
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_bool_array_after_for@4
    // tests/artifacts/Arrays/static_size.py:81
    // arr.append(i % 2 == 0)
    frame_dig 6
    dup
    pushint 2 // 2
    %
    !
    frame_dig 4
    swap
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:80
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    frame_bury 6
    b test_bool_array_for_header@1

test_bool_array_after_for@4:
    frame_dig 4
    dupn 2
    // tests/artifacts/Arrays/static_size.py:82
    // assert arr.length == length, "expected correct length"
    len
    frame_dig -1
    ==
    assert // expected correct length
    dig 1
    // tests/artifacts/Arrays/static_size.py:85
    // arr2.extend(arr)
    concat // on error: max array length exceeded
    // tests/artifacts/Arrays/static_size.py:86
    // assert arr2.length == length * 2, "expected correct length"
    len
    frame_dig -1
    pushint 2 // 2
    *
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:88
    // count = UInt64(0)
    intc_0 // 0
    frame_bury 1
    // tests/artifacts/Arrays/static_size.py:89
    // for val in arr:
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 3

test_bool_array_for_header@5:
    // tests/artifacts/Arrays/static_size.py:89
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_bool_array_after_for@10
    frame_dig 4
    frame_dig 3
    intc_1 // 1
    extract3 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    frame_dig 1
    frame_bury 2
    // tests/artifacts/Arrays/static_size.py:90
    // if val:
    bz test_bool_array_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:91
    // count += 1
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 2

test_bool_array_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_1 // 1
    +
    frame_bury 3
    b test_bool_array_for_header@5

test_bool_array_after_for@10:
    // tests/artifacts/Arrays/static_size.py:92
    // return count
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_conversion(length: uint64) -> bytes:
test_arc4_conversion:
    // tests/artifacts/Arrays/static_size.py:94-95
    // @arc4.abimethod()
    // def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
    proto 1 1
    bytec_3 // ""
    // tests/artifacts/Arrays/static_size.py:96
    // arr = ReferenceArray[arc4.UInt64]()
    dupn 4
    // tests/artifacts/Arrays/static_size.py:99
    // for i in urange(1, length + 1):
    frame_dig -1
    intc_1 // 1
    +
    intc_1 // 1

test_arc4_conversion_for_header@1:
    // tests/artifacts/Arrays/static_size.py:99
    // for i in urange(1, length + 1):
    frame_dig 6
    frame_dig 5
    <
    bz test_arc4_conversion_after_for@4
    // tests/artifacts/Arrays/static_size.py:100
    // arr.append(arc4.UInt64(i))
    frame_dig 6
    dup
    itob
    frame_dig 4
    swap
    concat // on error: max array length exceeded
    frame_bury 4
    // tests/artifacts/Arrays/static_size.py:99
    // for i in urange(1, length + 1):
    intc_1 // 1
    +
    frame_bury 6
    b test_arc4_conversion_for_header@1

test_arc4_conversion_after_for@4:
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:101
    // assert arr.length == length, "expected correct length"
    len
    intc_2 // 8
    /
    dup
    frame_bury 0
    frame_dig -1
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:102
    // count = UInt64(0)
    intc_0 // 0
    frame_bury 1
    intc_0 // 0
    frame_bury 3

test_arc4_conversion_for_header@5:
    // tests/artifacts/Arrays/static_size.py:103
    // for val in arr:
    frame_dig 3
    frame_dig 0
    <
    bz test_arc4_conversion_after_for@10
    frame_dig 4
    frame_dig 3
    intc_2 // 8
    *
    intc_2 // 8
    extract3 // on error: index access is out of bounds
    // tests/artifacts/Arrays/static_size.py:104
    // if val:
    bytec_3 // 0x
    b!=
    frame_dig 1
    frame_bury 2
    bz test_arc4_conversion_after_if_else@8
    // tests/artifacts/Arrays/static_size.py:105
    // count += 1
    frame_dig 1
    intc_1 // 1
    +
    frame_bury 2

test_arc4_conversion_after_if_else@8:
    frame_dig 2
    frame_bury 1
    frame_dig 3
    intc_1 // 1
    +
    frame_bury 3
    b test_arc4_conversion_for_header@5

test_arc4_conversion_after_for@10:
    // tests/artifacts/Arrays/static_size.py:107
    // arc4_arr = arc4.DynamicArray[arc4.UInt64]()
    bytec 4 // 0x0000
    frame_dig 4
    // tests/artifacts/Arrays/static_size.py:108
    // arc4_arr.extend(arr)
    concat // on error: max array length exceeded
    dup
    extract 2 0
    len
    intc_2 // 8
    /
    itob
    extract 6 2
    replace2 0
    // tests/artifacts/Arrays/static_size.py:110
    // return arc4_arr
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.sum_array(arc4_arr: bytes) -> uint64:
sum_array:
    // tests/artifacts/Arrays/static_size.py:112-113
    // @arc4.abimethod()
    // def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
    proto 1 1
    // tests/artifacts/Arrays/static_size.py:115
    // arr.extend(arc4_arr)
    frame_dig -1
    extract 2 0
    dup
    // tests/artifacts/Arrays/static_size.py:117
    // total = UInt64(0)
    intc_0 // 0
    swap
    // tests/artifacts/Arrays/static_size.py:118
    // for item in arr:
    len
    intc_2 // 8
    /
    intc_0 // 0

sum_array_for_header@1:
    // tests/artifacts/Arrays/static_size.py:118
    // for item in arr:
    frame_dig 3
    frame_dig 2
    <
    bz sum_array_after_for@4
    frame_dig 0
    frame_dig 3
    dup
    cover 2
    intc_2 // 8
    *
    // tests/artifacts/Arrays/static_size.py:119
    // total += item.native
    extract_uint64
    frame_dig 1
    +
    frame_bury 1
    intc_1 // 1
    +
    frame_bury 3
    b sum_array_for_header@1

sum_array_after_for@4:
    // tests/artifacts/Arrays/static_size.py:121
    // return total
    frame_dig 1
    frame_bury 0
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.xtra() -> uint64, uint64, bytes, bytes, bytes:
xtra:
    // tests/artifacts/Arrays/static_size.py:125
    // self.count += 1
    intc_0 // 0
    bytec_1 // "count"
    app_global_get_ex
    assert // check self.count exists
    intc_1 // 1
    +
    bytec_1 // "count"
    dig 1
    app_global_put
    // tests/artifacts/Arrays/static_size.py:127
    // a=Txn.num_app_args,
    txn NumAppArgs
    // tests/artifacts/Arrays/static_size.py:129
    // c=Txn.sender,
    txn Sender
    // tests/artifacts/Arrays/static_size.py:130
    // d=self.more(),
    callsub more
    // tests/artifacts/Arrays/static_size.py:131
    // e=BigUInt(self.count),
    intc_0 // 0
    bytec_1 // "count"
    app_global_get_ex
    assert // check self.count exists
    itob
    // tests/artifacts/Arrays/static_size.py:126-132
    // return Xtra(
    //     a=Txn.num_app_args,
    //     b=self.count,
    //     c=Txn.sender,
    //     d=self.more(),
    //     e=BigUInt(self.count),
    // )
    uncover 3
    cover 4
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.more() -> bytes:
more:
    // tests/artifacts/Arrays/static_size.py:136
    // return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
    intc_0 // 0
    bytec_1 // "count"
    app_global_get_ex
    assert // check self.count exists
    dup
    intc_1 // 1
    +
    itob
    dig 1
    uncover 2
    *
    itob
    concat
    retsub


// tests.artifacts.Arrays.static_size.StaticSizeContract.test_arc4_bool() -> bytes:
test_arc4_bool:
    // tests/artifacts/Arrays/static_size.py:138-139
    // @arc4.abimethod()
    // def test_arc4_bool(self) -> ImmutableArray[arc4.Bool]:
    proto 0 1
    // tests/artifacts/Arrays/static_size.py:141
    // arr.append(arc4.Bool(Txn.sender == Txn.receiver))
    txn Sender
    txn Receiver
    ==
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    // tests/artifacts/Arrays/static_size.py:142
    // arr.append(arc4.Bool(Txn.sender != Txn.receiver))
    txn Sender
    txn Receiver
    !=
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    concat // on error: max array length exceeded
    dupn 2
    uncover 2
    // tests/artifacts/Arrays/static_size.py:145
    // dyn_arr.extend(arr)
    dup
    len
    // tests/artifacts/Arrays/static_size.py:144
    // dyn_arr = arc4.DynamicArray[arc4.Bool]()
    bytec 4 // 0x0000
    // tests/artifacts/Arrays/static_size.py:145
    // dyn_arr.extend(arr)
    cover 2
    intc_2 // 8
    callsub dynamic_array_concat_bits
    dup
    cover 2
    // tests/artifacts/Arrays/static_size.py:146
    // assert dyn_arr.length == 2, "expected correct length"
    dup
    intc_0 // 0
    extract_uint16
    dup
    cover 3
    dup
    pushint 2 // 2
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:147
    // assert dyn_arr.bytes.length == 3, "expected 3 bytes"
    dig 1
    len
    pushint 3 // 3
    ==
    assert // expected 3 bytes
    // tests/artifacts/Arrays/static_size.py:148
    // assert dyn_arr[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
    dup
    assert // index access is out of bounds
    dig 1
    intc_3 // 16
    getbit
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 0
    // tests/artifacts/Arrays/static_size.py:149
    // assert dyn_arr[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
    intc_1 // 1
    >
    assert // index access is out of bounds
    pushint 17 // 17
    getbit
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 1
    intc_0 // 0

test_arc4_bool_for_header@1:
    // tests/artifacts/Arrays/static_size.py:152-154
    // # note: not supported currently
    // # arr2.extend(dyn_array)
    // for b in dyn_arr:
    frame_dig 4
    frame_dig 2
    <
    bz test_arc4_bool_after_for@4
    frame_dig 4
    dup
    intc_3 // 16
    +
    frame_dig 1
    swap
    getbit
    bytec_2 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    frame_dig 3
    // tests/artifacts/Arrays/static_size.py:155
    // arr2.append(b)
    swap
    concat // on error: max array length exceeded
    frame_bury 3
    intc_1 // 1
    +
    frame_bury 4
    b test_arc4_bool_for_header@1

test_arc4_bool_after_for@4:
    frame_dig 3
    // tests/artifacts/Arrays/static_size.py:156
    // assert arr2.length == 4, "expected correct length"
    dup
    len
    pushint 4 // 4
    ==
    assert // expected correct length
    // tests/artifacts/Arrays/static_size.py:157
    // assert arr2[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
    dup
    extract 0 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 0
    // tests/artifacts/Arrays/static_size.py:158
    // assert arr2[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
    dup
    extract 1 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 1
    // tests/artifacts/Arrays/static_size.py:159
    // assert arr2[2] == (Txn.sender == Txn.receiver), "expected correct value at 2"
    dup
    extract 2 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    ==
    ==
    assert // expected correct value at 2
    // tests/artifacts/Arrays/static_size.py:160
    // assert arr2[3] == (Txn.sender != Txn.receiver), "expected correct value at 3"
    extract 3 1 // on error: index access is out of bounds
    intc_0 // 0
    getbit
    txn Sender
    txn Receiver
    !=
    ==
    assert // expected correct value at 3
    frame_dig 0
    // tests/artifacts/Arrays/static_size.py:162
    // return arr.freeze()
    dup
    len
    bytec 4 // 0x0000
    cover 2
    intc_2 // 8
    callsub dynamic_array_concat_bits
    frame_bury 0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "CiAEAQAIUCYEBWNvdW50BBUffHUAAWExGEAAAygjZzEbQQC9ggYEKNfBuAT6nLlzBGA5okAE+P1opwQfAo2xBAlrOlk2GgCOBgBtAFIAPwAqABYAAiNDMRkURDEYRDYaAYgC7RYpTFCwIkMxGRREMRhENhoBF4gCZClMULAiQzEZFEQxGEQ2GgEXiAHhFilMULAiQzEZFEQxGEQ2GgGIAb8pTFCwIkMxGRREMRhENhoBSVcAEExXEBCIAWUpTFCwIkMxGRREMRhENhoBNhoCFzYaAzYaBBeIABIWKUxQsCJDMRlA/28xGBREIkOKBAEjSSpHBSgjZ4gCjIgCiYgChk8LFoAQAAAAAAAAAAAAAAAAAAAAAExQTwsWUE8KUE8JUIv9Fov8TFBPCRZQTwgWUE8HUE8GUFCL/xaL/kxQTwUWUE8EFlBPA1BPAlBQI4sJgQMMQQA4iwiLCUlOAiULJVhJgRhbSwIiCExLARJETFdAEElXAAhPA4ECCBaoRFcICEsBSwILFqhEjAlC/8CLCEkVJQpJjAQWVwYCSwFQK7xIK0y/VwBQSYwASVcACIwBJFuMAyOMBSKMB4sHiwQMQQBaiwiLByULJVhHAlcACEwkW4wGiwGkQQA2iwAjW0wjWwmMAosGiwMMQQAciwOLBgmLAkkLTEkLCJKLBQiMBYsHIgiMB0L/sosGiwMJQv/hI1uLACNbCYwCQv/IiwWMAImKAgGL/ov/UEkVgRAKSSIJgRALSwJMgRBYVwAQSYv/EkRMFlcGAk8CUEkjWSIJSwFXAgBMgRALgRBYTwISRImKAQGL/0iAAgACi/9QiYoBASpHBIv/IggiiwaLBQxBAB2LBkmBAhgUggIBAAGATwJNiwRMUIwEIgiMBkL/24sEFUmMAIv/EkQjjAEjjAOLA4sADEEAIosEiwMiWCNTiwGMAkEABosBIgiMAosCjAGLAyIIjANC/9aLAYwAiYoBASpHBIv/IggiiwaLBQxBABGLBkkWiwRMUIwEIgiMBkL/54sEFSQKSYwAi/8SRCOMASOMA4sDiwAMQQAniwSLAyQLJFhXAAgqqYsBjAJBAAaLASIIjAKLAowBiwMiCIwDQv/RiwRJFSQKFlcGAkxQjACJigEBi/9XAgBJI0wVJAojiwOLAgxBABmLAIsDSU4CJAskWCNbiwEIjAEiCIwDQv/fiwGMAIkjKGVEIggoTGcxGyMoZUQxAIgAAYkjKGVEIggWIyhlRCMoZUQLFlCJ",
+        "approval": "CiAFAAEIEJABJgUEFR98dQVjb3VudAEAAAIAADEYQAADKSJnMRtBANSCBwQo18G4BPqcuXMEYDmiQAT4/WinBB8CjbEECWs6WQSNbjolNhoAjgcAfQBiAE8AOgAmABIAAiJDMRkURDEYRIgEIChMULAjQzEZFEQxGEQ2GgGIA7AWKExQsCNDMRkURDEYRDYaAReIAyQoTFCwI0MxGRREMRhENhoBF4gCmBYoTFCwI0MxGRREMRhENhoBiAJxKExQsCNDMRkURDEYRDYaAUlXABBMVxAQiAIfKExQsCNDMRkURDEYRDYaATYaAhc2GgM2GgQXiACRFihMULAjQzEZQP9fMRgURCNDigQBK0cCi/wiWUcCi/4ISRZXBgCL/ExcAElPAk8DgQcIJApJTgNMgQcIJApJTgMMQQAMiwaLBQmviwRMUIwHiweMBCKMAIsDJQhJjAKL/giMAYsCiwEMQQAgi/2LAElOAlOLBIsCSU4DTwJUjAQjCIwCi/8IjABC/9iLBIwAiYoEASJJK0cFKSJniALNiALKiALHTw4WTw4WUE8NUE8MUEsLFYFADkSBQK9PDEsBq08CTFCAEAAAAAAAAAAAAAAAAAAAAABMUIv9Fov8TFBPDBZPDBZQTwtQTwpQSwkVgUAORE8JSwSrUFBQi/8Wi/5MUE8HFk8HFlBPBlBPBVBLBBWBQA5ETwRPBKtQUFAiiwmBAwxBAD+LCIsJSU4CIQQLIQRYVxCASSRbTFcwEEsCIwhPAksBEkRLAVcACE8DgQIIFqhETFcICEsBSwILFqhEjAlC/7mLCEkVIQQKSYwCFlcGAksBUIABYbxIgAFhTL9XAJBJjABJVwAIjAEkW4wEIowFI4wHiweLAgxBAFyLCIsHIQQLIQRYRwJXAAhMJFuMBosBpEEANosAIltMIlsJjAOLBosEDEEAHIsEiwYJiwNJC0xJCwiSiwUIjAWLByMIjAdC/7CLBosECUL/4SJbiwAiWwmMA0L/yIsFjACJigIBi/6L/1BJFSUKSSMJJQtLAkwlWEmL/xJETBZXBgJPAlBJIlkjCUsBVwIATCULJVhPAhJEiYoBAYv/SIv/FSUKFlcGAov/UImKAQErRwSL/yMII4sGiwUMQQAZiwZJgQIYFIsETCoiTwJUUIwEIwiMBkL/34sERwIVi/8SREsBUBWL/4ECCxJEIowBFYwAIowDiwOLAAxBACKLBIsDI1giU4sBjAJBAAaLASMIjAKLAowBiwMjCIwDQv/WiwGMAImKAQErRwSL/yMII4sGiwUMQQARiwZJFosETFCMBCMIjAZC/+eLBBUkCkmMAIv/EkQijAEijAOLA4sADEEAJIsEiwMkCyRYK6mLAYwCQQAGiwEjCIwCiwKMAYsDIwiMA0L/1CcEiwRQSVcCABUkChZXBgJcAIwAiYoBAYv/VwIASSJMFSQKIosDiwIMQQAWiwCLA0lOAiQLW4sBCIwBIwiMA0L/4osBjACJIillRCMIKUsBZzEbMQCIAAoiKWVEFk8DTgSJIillREkjCBZLAU8CCxZQiYoAATEAMQcSKiJPAlQxADEHEyoiTwJUUEcCTwJJFScETgIkiPxVSU4CSSJZSU4DSYECEkRLARWBAxJESURLASVTKiJPAlQiUzEAMQcSEkQjDUSBEVMqIk8CVCJTMQAxBxMSRCKLBIsCDEEAG4sESSUIiwFMUyoiTwJUiwNMUIwDIwiMBEL/3YsDSRWBBBJESVcAASJTMQAxBxISRElXAQEiUzEAMQcTEkRJVwIBIlMxADEHEhJEVwMBIlMxADEHExJEiwBJFScETgIkiPutjACJ",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/Arrays/immutable.py b/tests/artifacts/Arrays/immutable.py
index cc52abb7..3474fd13 100644
--- a/tests/artifacts/Arrays/immutable.py
+++ b/tests/artifacts/Arrays/immutable.py
@@ -1,10 +1,15 @@
 import typing
 
 from algopy import (
-    Array,
+    BigUInt,
+    Box,
     Bytes,
+    FixedArray,
     ImmutableArray,
+    ImmutableFixedArray,
+    ReferenceArray,
     String,
+    Struct,
     Txn,
     UInt64,
     arc4,
@@ -13,6 +18,7 @@
     subroutine,
     uenumerate,
     urange,
+    zero_bytes,
 )
 
 
@@ -71,6 +77,19 @@ class NineBoolTuple(typing.NamedTuple):
     bar: UInt64
 
 
+class MyStruct(arc4.Struct, frozen=True):
+    foo: arc4.UInt64
+    bar: arc4.UInt64
+
+
+class NativeStruct(Struct, frozen=True):
+    foo: UInt64
+    bar: UInt64
+
+
+NativeStruct3 = ImmutableFixedArray[NativeStruct, typing.Literal[3]]
+
+
 class ImmutableArrayContract(arc4.ARC4Contract):
     @arc4.abimethod()
     def test_uint64_array(self) -> None:
@@ -108,6 +127,31 @@ def test_uint64_array(self) -> None:
 
         self.a = arr
 
+    @arc4.abimethod()
+    def test_biguint_array(self) -> None:
+        arr = ImmutableArray[BigUInt]()
+        assert arr.length == 0
+
+        arr = arr.append(BigUInt(Txn.num_app_args - 1))
+        assert arr.length == 1
+        assert arr[-1] == 0
+
+        arr = add_xb(arr, UInt64(5))
+        assert arr.length == 6
+        assert arr[-1] == 4
+
+        arr = arr.append(BigUInt(2**512 - 1) - Txn.num_app_args)
+        assert arr.length == 7
+        assert arr[-1] == 2**512 - 2
+        assert arr[0] == 0
+
+        arr = arr.append(BigUInt(2**512 - 1))
+        assert arr.length == 8
+        assert arr[-1] == 2**512 - 1
+        assert arr[0] == 0
+
+        Box(ImmutableArray[BigUInt], key=b"biguint").value = arr
+
     @arc4.abimethod()
     def test_bool_array(self, length: UInt64) -> None:
         arr = ImmutableArray[bool]()
@@ -353,7 +397,7 @@ def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicS
     def test_convert_to_array_and_back(
         self, arr: ImmutableArray[MyTuple], append: UInt64
     ) -> ImmutableArray[MyTuple]:
-        mutable = Array[MyTuple]()
+        mutable = ReferenceArray[MyTuple]()
         mutable.extend(arr)
         for i in urange(append):
             mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
@@ -397,6 +441,49 @@ def test_concat_immutable_dynamic(
     ) -> ImmutableArray[MyDynamicSizedTuple]:
         return imm1 + imm2
 
+    @arc4.abimethod()
+    def test_immutable_arc4(self, imm: ImmutableArray[MyStruct]) -> ImmutableArray[MyStruct]:
+        assert imm, "expected non empty array"
+        imm = imm.replace(imm.length - 1, imm[0])
+        return imm
+
+    @arc4.abimethod()
+    def test_imm_fixed_arr(self) -> NativeStruct3:
+        arr1 = zero_bytes(NativeStruct3)
+        struct12 = NativeStruct(Txn.num_app_args + 1, Txn.num_app_args + 2)
+        arr2 = NativeStruct3((struct12, struct12, struct12))
+        arr3 = NativeStruct3.full(struct12)
+        assert arr1 != arr2, "expected arrays to be different"
+        assert arr2 == arr3, "expected arrays to be the same"
+
+        for i in urange(3):
+            arr1 = arr1.replace(i, struct12)
+
+        assert arr1 == arr2, "expected arrays to be the same"
+
+        for struct_it in arr1:
+            assert struct_it == struct12, "expected items on iteration to be the same"
+
+        self.imm_fixed_arr = arr1
+        assert self.imm_fixed_arr == arr2, "expected array in storage to be the same"
+
+        mut_arr: FixedArray[NativeStruct, typing.Literal[3]] = FixedArray(arr1)
+        assert sum_imm_fixed(mut_arr.freeze()) == 15, "expected sum to be 15"
+
+        mut_arr[0] = NativeStruct(UInt64(), UInt64())
+        assert sum_imm_fixed(mut_arr.freeze()) == 10, "expected sum to be 10"
+
+        return self.imm_fixed_arr
+
+
+@subroutine
+def sum_imm_fixed(arr: NativeStruct3) -> UInt64:
+    total = UInt64(0)
+    for item in arr:
+        total += item.foo
+        total += item.bar
+    return total
+
 
 @subroutine
 def times(n: UInt64) -> String:
@@ -420,6 +507,13 @@ def pop_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
     return arr
 
 
+@subroutine
+def add_xb(arr: ImmutableArray[BigUInt], x: UInt64) -> ImmutableArray[BigUInt]:
+    for i in urange(x):
+        arr = arr.append(BigUInt(i))
+    return arr
+
+
 @subroutine
 def sum_arr(arr: ImmutableArray[UInt64]) -> UInt64:
     total = UInt64()
diff --git a/tests/artifacts/Arrays/static_size.py b/tests/artifacts/Arrays/static_size.py
index 2123a445..864c0771 100644
--- a/tests/artifacts/Arrays/static_size.py
+++ b/tests/artifacts/Arrays/static_size.py
@@ -1,6 +1,18 @@
 import typing
 
-from algopy import Account, Array, Box, ImmutableArray, Txn, UInt64, arc4, op, subroutine, urange
+from algopy import (
+    Account,
+    BigUInt,
+    Box,
+    ImmutableArray,
+    ReferenceArray,
+    Txn,
+    UInt64,
+    arc4,
+    op,
+    subroutine,
+    urange,
+)
 
 
 class More(arc4.Struct, frozen=True):
@@ -13,6 +25,7 @@ class Xtra(typing.NamedTuple):
     b: UInt64
     c: Account
     d: More
+    e: BigUInt
 
 
 class Point(typing.NamedTuple):
@@ -28,7 +41,7 @@ def __init__(self) -> None:
     @arc4.abimethod()
     def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
         self.count = UInt64(0)
-        path = Array(
+        path = ReferenceArray(
             Point(x=arc4.UInt64(), y=UInt64(), other=self.xtra()),
             Point(x=x1, y=y1, other=self.xtra()),
             Point(x=x2, y=y2, other=self.xtra()),
@@ -43,7 +56,7 @@ def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -
 
     @arc4.abimethod()
     def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
-        arr = Array[More]()
+        arr = ReferenceArray[More]()
         arr.extend(some_more)
         last = arr[-1]
         assert last == some_more[1]
@@ -55,18 +68,23 @@ def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray
     def test_extend_from_arc4_tuple(
         self, some_more: arc4.Tuple[More, More]
     ) -> ImmutableArray[More]:
-        arr = Array[More]()
+        arr = ReferenceArray[More]()
         arr.extend(some_more)
         return arr.freeze()
 
     @arc4.abimethod()
     def test_bool_array(self, length: UInt64) -> UInt64:
-        arr = Array[bool]()
+        arr = ReferenceArray[bool]()
         assert arr.length == 0
 
         for i in urange(1, length + 1):
             arr.append(i % 2 == 0)
         assert arr.length == length, "expected correct length"
+
+        arr2 = arr.copy()
+        arr2.extend(arr)
+        assert arr2.length == length * 2, "expected correct length"
+
         count = UInt64(0)
         for val in arr:
             if val:
@@ -75,7 +93,7 @@ def test_bool_array(self, length: UInt64) -> UInt64:
 
     @arc4.abimethod()
     def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
-        arr = Array[arc4.UInt64]()
+        arr = ReferenceArray[arc4.UInt64]()
         assert arr.length == 0
 
         for i in urange(1, length + 1):
@@ -93,7 +111,7 @@ def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]
 
     @arc4.abimethod()
     def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
-        arr = Array[arc4.UInt64]()
+        arr = ReferenceArray[arc4.UInt64]()
         arr.extend(arc4_arr)
 
         total = UInt64(0)
@@ -110,15 +128,42 @@ def xtra(self) -> Xtra:
             b=self.count,
             c=Txn.sender,
             d=self.more(),
+            e=BigUInt(self.count),
         )
 
     @subroutine(inline=False)
     def more(self) -> More:
         return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
 
+    @arc4.abimethod()
+    def test_arc4_bool(self) -> ImmutableArray[arc4.Bool]:
+        arr = ReferenceArray[arc4.Bool]()
+        arr.append(arc4.Bool(Txn.sender == Txn.receiver))
+        arr.append(arc4.Bool(Txn.sender != Txn.receiver))
+
+        dyn_arr = arc4.DynamicArray[arc4.Bool]()
+        dyn_arr.extend(arr)
+        assert dyn_arr.length == 2, "expected correct length"
+        assert dyn_arr.bytes.length == 3, "expected 3 bytes"
+        assert dyn_arr[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
+        assert dyn_arr[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
+
+        arr2 = arr.copy()
+        # note: not supported currently
+        # arr2.extend(dyn_array)
+        for b in dyn_arr:
+            arr2.append(b)
+        assert arr2.length == 4, "expected correct length"
+        assert arr2[0] == (Txn.sender == Txn.receiver), "expected correct value at 0"
+        assert arr2[1] == (Txn.sender != Txn.receiver), "expected correct value at 1"
+        assert arr2[2] == (Txn.sender == Txn.receiver), "expected correct value at 2"
+        assert arr2[3] == (Txn.sender != Txn.receiver), "expected correct value at 3"
+
+        return arr.freeze()
+
 
 @subroutine
-def path_length(path: Array[Point]) -> UInt64:
+def path_length(path: ReferenceArray[Point]) -> UInt64:
     last_point = path[0]
     length = UInt64()
     for point_idx in urange(1, path.length):
diff --git a/tests/artifacts/Arrays/uint64.py b/tests/artifacts/Arrays/uint64.py
index 0e9a90d6..fba83e7a 100644
--- a/tests/artifacts/Arrays/uint64.py
+++ b/tests/artifacts/Arrays/uint64.py
@@ -1,10 +1,19 @@
-from algopy import Array, Txn, UInt64, arc4, op, subroutine, uenumerate, urange
+from algopy import (
+    ReferenceArray,
+    Txn,
+    UInt64,
+    arc4,
+    op,
+    subroutine,
+    uenumerate,
+    urange,
+)
 
 
 class Contract(arc4.ARC4Contract):
     @arc4.abimethod()
     def test_array(self) -> None:
-        arr = Array[UInt64]()
+        arr = ReferenceArray[UInt64]()
         assert arr.length == 0
 
         arr.append(UInt64(42))
@@ -40,9 +49,9 @@ def test_array(self) -> None:
 
     @arc4.abimethod()
     def test_array_extend(self) -> None:
-        arr = Array[UInt64]()
+        arr = ReferenceArray[UInt64]()
         add_x(arr, UInt64(1))
-        arr2 = Array[UInt64]()
+        arr2 = ReferenceArray[UInt64]()
         arr2.append(UInt64(1))
         arr2.append(UInt64(2))
         arr2.append(UInt64(3))
@@ -52,7 +61,7 @@ def test_array_extend(self) -> None:
 
     @arc4.abimethod()
     def test_array_multiple_append(self) -> None:
-        arr = Array[UInt64]()
+        arr = ReferenceArray[UInt64]()
         add_x(arr, UInt64(1))
         arr.append(UInt64(1))
         arr.append(UInt64(2))
@@ -65,7 +74,7 @@ def overhead(self) -> None:
 
     @arc4.abimethod()
     def test_array_too_long(self) -> None:
-        array = Array[UInt64]()
+        array = ReferenceArray[UInt64]()
         for i in urange(512):
             array.append(i)
         assert array.length == 512, "array is expected length"
@@ -74,7 +83,7 @@ def test_array_too_long(self) -> None:
 
     @arc4.abimethod()
     def test_array_copy_and_extend(self) -> None:
-        array = Array[UInt64]()
+        array = ReferenceArray[UInt64]()
         for i in urange(5):
             array.append(i)
         array2 = array.copy()
@@ -96,7 +105,7 @@ def test_array_copy_and_extend(self) -> None:
 
     @arc4.abimethod()
     def test_array_evaluation_order(self) -> None:
-        arr = Array[UInt64]()
+        arr = ReferenceArray[UInt64]()
         arr.append(UInt64(3))
         append_length_and_return(arr).extend(append_length_and_return(arr))
         assert arr.length == 6
@@ -113,15 +122,24 @@ def test_array_evaluation_order(self) -> None:
         assert arr[7] == 7
         assert arr[3] == 6
 
+    @arc4.abimethod()
+    def test_array_assignment_maximum_cursage(self) -> None:
+        arr = ReferenceArray[UInt64]()
+        arr.append(UInt64(3))
+        append_length_and_return(arr)[0] = UInt64(42)
+        assert arr.length == 2
+        assert arr[0] == 42
+        assert arr[1] == 1
+
     @arc4.abimethod()
     def test_allocations(self, num: UInt64) -> None:
         for _i in urange(num):
-            alloc_test = Array[UInt64]()
+            alloc_test = ReferenceArray[UInt64]()
             add_x(alloc_test, UInt64(1))
 
     @arc4.abimethod()
     def test_iteration(self) -> None:
-        arr = Array[UInt64]()
+        arr = ReferenceArray[UInt64]()
         for val in urange(5):
             arr.append(val)
         assert arr.length == 5, "expected array of length 5"
@@ -142,7 +160,7 @@ def test_iteration(self) -> None:
             last = value
 
         arc4_arr = arc4.DynamicArray[arc4.UInt64]()
-        native_arr = Array[arc4.UInt64]()
+        native_arr = ReferenceArray[arc4.UInt64]()
         for i in urange(5):
             arc4_arr.append(arc4.UInt64(i))
             native_arr.append(arc4.UInt64(i))
@@ -156,7 +174,7 @@ def test_iteration(self) -> None:
     @arc4.abimethod()
     def test_quicksort(self) -> None:
         # create pseudo random array from sender address
-        rnd = Array[UInt64]()
+        rnd = ReferenceArray[UInt64]()
         for b in Txn.sender.bytes:
             rnd.append(op.btoi(b))
         assert rnd.length == 32, "expected array of length 32"
@@ -170,9 +188,20 @@ def test_quicksort(self) -> None:
             assert value >= last, "array is not sorted"
             last = value
 
+    @arc4.abimethod()
+    def test_unobserved_write(self) -> None:
+        arr = create_array()
+        last = arr.length - 1
+        arr[last] = UInt64(0)  # write
+        assert_last_is_zero(arr)
+        arr[last] = UInt64(1)  # write
+        assert arr[last] == 1
+
 
 @subroutine
-def quicksort_window(arr: Array[UInt64], window_left: UInt64, window_right: UInt64) -> None:
+def quicksort_window(
+    arr: ReferenceArray[UInt64], window_left: UInt64, window_right: UInt64
+) -> None:
     left = window_left
     right = window_right
     pivot = arr[(window_left + window_right) // 2]
@@ -223,21 +252,36 @@ def quicksort_window(arr: Array[UInt64], window_left: UInt64, window_right: UInt
         quicksort_window(arr, left, window_right)
 
 
+@subroutine(inline=False)
+def create_array() -> ReferenceArray[UInt64]:
+    arr = ReferenceArray[UInt64]()
+    for i in urange(5):
+        arr.append(i)
+    return arr
+
+
+@subroutine(inline=False)
+def assert_last_is_zero(arr: ReferenceArray[UInt64]) -> None:
+    assert arr[arr.length - 1] == 0
+
+
 @subroutine
-def return_ref(arr: Array[UInt64], arr2: Array[UInt64]) -> Array[UInt64]:
+def return_ref(
+    arr: ReferenceArray[UInt64], arr2: ReferenceArray[UInt64]
+) -> ReferenceArray[UInt64]:
     arr.append(UInt64(99))
     arr2.append(UInt64(100))
     return arr
 
 
 @subroutine
-def add_x(arr: Array[UInt64], x: UInt64) -> None:
+def add_x(arr: ReferenceArray[UInt64], x: UInt64) -> None:
     for i in urange(x):
         arr.append(i)
 
 
 @subroutine
-def pop_x(arr: Array[UInt64], x: UInt64, expected: UInt64) -> None:
+def pop_x(arr: ReferenceArray[UInt64], x: UInt64, expected: UInt64) -> None:
     for _i in urange(x):
         popped = arr.pop()
         assert popped == expected
@@ -245,11 +289,11 @@ def pop_x(arr: Array[UInt64], x: UInt64, expected: UInt64) -> None:
 
 
 @subroutine
-def append_length_and_return(arr: Array[UInt64]) -> Array[UInt64]:
+def append_length_and_return(arr: ReferenceArray[UInt64]) -> ReferenceArray[UInt64]:
     arr.append(arr.length)
     return arr
 
 
 @subroutine
-def do_something_with_array(arr: Array[UInt64]) -> None:
+def do_something_with_array(arr: ReferenceArray[UInt64]) -> None:
     arr.append(UInt64(1))
diff --git a/tests/artifacts/BoxContract/data/BoxContract.approval.teal b/tests/artifacts/BoxContract/data/BoxContract.approval.teal
index 1ac45695..c21197d3 100644
--- a/tests/artifacts/BoxContract/data/BoxContract.approval.teal
+++ b/tests/artifacts/BoxContract/data/BoxContract.approval.teal
@@ -84,37 +84,27 @@ read_enums:
     // assert op.Box.get(b"oca")[0] == op.itob(self.oca.value)
     bytec_0 // 0x6f6361
     box_get
-    pop
-    bytec_0 // "oca"
-    box_get
     assert // check self.oca exists
+    dup
     btoi
     itob
+    swap
+    dig 1
     ==
     assert
     // tests/artifacts/BoxContract/contract.py:17
     // assert op.Box.get(b"txn")[0] == op.itob(self.txn.value)
     bytec_1 // 0x74786e
     box_get
-    pop
-    bytec_1 // "txn"
-    box_get
     assert // check self.txn exists
+    dup
     btoi
     itob
+    swap
+    dig 1
     ==
     assert
     // tests/artifacts/BoxContract/contract.py:19
     // return arc4.Tuple((arc4.UInt64(self.oca.value), arc4.UInt64(self.txn.value)))
-    bytec_0 // "oca"
-    box_get
-    assert // check self.oca exists
-    btoi
-    itob
-    bytec_1 // "txn"
-    box_get
-    assert // check self.txn exists
-    btoi
-    itob
     concat
     retsub
diff --git a/tests/artifacts/BoxContract/data/BoxContract.arc32.json b/tests/artifacts/BoxContract/data/BoxContract.arc32.json
index edac3fe9..b2355405 100644
--- a/tests/artifacts/BoxContract/data/BoxContract.arc32.json
+++ b/tests/artifacts/BoxContract/data/BoxContract.arc32.json
@@ -12,7 +12,7 @@
         }
     },
     "source": {
-        "approval": "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",
+        "approval": "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",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/BoxContract/data/BoxContract.arc56.json b/tests/artifacts/BoxContract/data/BoxContract.arc56.json
index c18a0190..0368c56d 100644
--- a/tests/artifacts/BoxContract/data/BoxContract.arc56.json
+++ b/tests/artifacts/BoxContract/data/BoxContract.arc56.json
@@ -104,15 +104,13 @@
                 },
                 {
                     "pc": [
-                        104,
-                        121
+                        101
                     ],
                     "errorMessage": "check self.oca exists"
                 },
                 {
                     "pc": [
-                        114,
-                        126
+                        112
                     ],
                     "errorMessage": "check self.txn exists"
                 }
@@ -125,19 +123,19 @@
         }
     },
     "source": {
-        "approval": "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",
+        "approval": "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",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "CiABASYCA29jYQN0eG4xG0EAOYICBPJsbUIE7xhs9zYaAI4CABgAA4EAQzEZFEQxGESIAC6ABBUffHVMULAiQzEZFEQxGESIAA0iQzEZQP/XMRgURCJDIhYoTL+BBhYpTL+JKL5IKL5EFxYSRCm+SCm+RBcWEkQovkQXFim+RBcWUIk=",
+        "approval": "CiABASYCA29jYQN0eG4xG0EAOYICBPJsbUIE7xhs9zYaAI4CABgAA4EAQzEZFEQxGESIAC6ABBUffHVMULAiQzEZFEQxGESIAA0iQzEZQP/XMRgURCJDIhYoTL+BBhYpTL+JKL5ESRcWTEsBEkQpvkRJFxZMSwESRFCJ",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/CreatedAppAsset/data/AppCall.arc56.json b/tests/artifacts/CreatedAppAsset/data/AppCall.arc56.json
index 475f58ab..bf5b39b6 100644
--- a/tests/artifacts/CreatedAppAsset/data/AppCall.arc56.json
+++ b/tests/artifacts/CreatedAppAsset/data/AppCall.arc56.json
@@ -93,8 +93,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc56.json b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc56.json
index a76c2840..b0406d65 100644
--- a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc56.json
+++ b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc56.json
@@ -180,8 +180,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal b/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal
index 3714d616..691c4f3a 100644
--- a/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal
+++ b/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal
@@ -81,16 +81,17 @@ main_verify_ecdsa_decompress_r1_route@14:
     extract 6 2
     uncover 2
     concat
-    dig 1
+    dup
+    len
+    intc_2 // 4
+    +
+    dig 2
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 3
     concat
-    dig 1
-    len
-    intc_2 // 4
-    +
+    swap
     itob
     extract 6 2
     bytec_2 // 0x0004
@@ -128,16 +129,17 @@ main_verify_ecdsa_decompress_k1_route@13:
     extract 6 2
     uncover 2
     concat
-    dig 1
+    dup
+    len
+    intc_2 // 4
+    +
+    dig 2
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 3
     concat
-    dig 1
-    len
-    intc_2 // 4
-    +
+    swap
     itob
     extract 6 2
     bytec_2 // 0x0004
@@ -181,16 +183,17 @@ main_verify_ecdsa_recover_r1_route@12:
     extract 6 2
     uncover 2
     concat
-    dig 1
+    dup
+    len
+    intc_2 // 4
+    +
+    dig 2
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 3
     concat
-    dig 1
-    len
-    intc_2 // 4
-    +
+    swap
     itob
     extract 6 2
     bytec_2 // 0x0004
@@ -234,16 +237,17 @@ main_verify_ecdsa_recover_k1_route@11:
     extract 6 2
     uncover 2
     concat
-    dig 1
+    dup
+    len
+    intc_2 // 4
+    +
+    dig 2
     len
     itob
     extract 6 2
-    uncover 2
+    uncover 3
     concat
-    dig 1
-    len
-    intc_2 // 4
-    +
+    swap
     itob
     extract 6 2
     bytec_2 // 0x0004
diff --git a/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json b/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json
index 3e99cab2..5ad6251b 100644
--- a/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json
+++ b/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json
@@ -67,7 +67,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 4 3000
    bytecblock 0x151f7c75 0x00 0x0004 0x068101
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@18
    pushbytess 0x3456c4c3 0xe8442b84 0x65f567aa 0x258455b1 0x35af0f38 0x6582c997 0x6298ffbb 0x3885b54f 0x2164e0bf 0x755b79a5 0xf06bb077 0x133f8ccc 0x2f7c68a9 // method "verify_sha256(byte[],uint64)byte[]", method "verify_sha3_256(byte[],uint64)byte[]", method "verify_keccak_256(byte[],uint64)byte[]", method "verify_sha512_256(byte[],uint64)byte[]", method "verify_ed25519verify(byte[],byte[],byte[])bool", method "verify_ed25519verify_bare(byte[],byte[],byte[])bool", method "verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_decompress_k1(byte[])(byte[],byte[])", method "verify_ecdsa_decompress_r1(byte[])(byte[],byte[])", method "verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)"
    txna ApplicationArgs 0
    match main_verify_sha256_route@3 main_verify_sha3_256_route@4 main_verify_keccak_256_route@5 main_verify_sha512_256_route@6 main_verify_ed25519verify_route@7 main_verify_ed25519verify_bare_route@8 main_verify_ecdsa_verify_k1_route@9 main_verify_ecdsa_verify_r1_route@10 main_verify_ecdsa_recover_k1_route@11 main_verify_ecdsa_recover_r1_route@12 main_verify_ecdsa_decompress_k1_route@13 main_verify_ecdsa_decompress_r1_route@14 main_verify_vrf_verify_route@15

main_after_if_else@22:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    intc_0 // 0
    return

main_verify_vrf_verify_route@15:
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    callsub verify_vrf_verify
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    pushbytes 0x0003
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_r1_route@14:
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_k1_route@13:
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_r1_route@12:
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_k1_route@11:
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_r1_route@10:
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_r1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_k1_route@9:
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_k1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_bare_route@8:
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    callsub verify_ed25519verify_bare
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_route@7:
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    callsub verify_ed25519verify
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha512_256_route@6:
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    callsub verify_sha512_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_keccak_256_route@5:
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    callsub verify_keccak_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha3_256_route@4:
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    callsub verify_sha3_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha256_route@3:
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_sha256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_bare_routing@18:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@22
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.util.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
ensure_budget:
    proto 2 0
    frame_dig -2
    pushint 10 // 10
    +

ensure_budget_while_top@1:
    frame_dig 0
    global OpcodeBudget
    >
    bz ensure_budget_after_while@7
    itxn_begin
    pushint 6 // appl
    itxn_field TypeEnum
    pushint 5 // DeleteApplication
    itxn_field OnCompletion
    bytec_3 // 0x068101
    itxn_field ApprovalProgram
    bytec_3 // 0x068101
    itxn_field ClearStateProgram
    frame_dig -1
    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4

ensure_budget_switch_case_next@6:
    itxn_submit
    b ensure_budget_while_top@1

ensure_budget_switch_case_1@4:
    global MinTxnFee
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_switch_case_0@3:
    intc_0 // 0
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_after_while@7:
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha256(a: bytes, pad_size: uint64) -> bytes:
verify_sha256:
    // tests/artifacts/CryptoOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_sha256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:7
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:8
    // result = op.sha256(a)
    sha256
    // tests/artifacts/CryptoOps/contract.py:9
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha3_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha3_256:
    // tests/artifacts/CryptoOps/contract.py:11-12
    // @arc4.abimethod()
    // def verify_sha3_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:13
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:14
    // result = op.sha3_256(a)
    sha3_256
    // tests/artifacts/CryptoOps/contract.py:15
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_keccak_256(a: bytes, pad_size: uint64) -> bytes:
verify_keccak_256:
    // tests/artifacts/CryptoOps/contract.py:17-18
    // @arc4.abimethod()
    // def verify_keccak_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:19
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:20
    // result = op.keccak256(a)
    keccak256
    // tests/artifacts/CryptoOps/contract.py:21
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha512_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha512_256:
    // tests/artifacts/CryptoOps/contract.py:23-24
    // @arc4.abimethod()
    // def verify_sha512_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:25
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:26
    // result = op.sha512_256(a)
    sha512_256
    // tests/artifacts/CryptoOps/contract.py:27
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify:
    // tests/artifacts/CryptoOps/contract.py:29-30
    // @arc4.abimethod()
    // def verify_ed25519verify(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:31
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:32
    // result = op.ed25519verify(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify
    // tests/artifacts/CryptoOps/contract.py:33
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify_bare:
    // tests/artifacts/CryptoOps/contract.py:35-36
    // @arc4.abimethod()
    // def verify_ed25519verify_bare(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:37
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:38
    // result = op.ed25519verify_bare(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify_bare
    // tests/artifacts/CryptoOps/contract.py:39
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_k1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_k1:
    // tests/artifacts/CryptoOps/contract.py:41-42
    // @arc4.abimethod()
    // def verify_ecdsa_verify_k1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:43
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:44
    // result_k1 = op.ecdsa_verify(op.ECDSA.Secp256k1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256k1
    // tests/artifacts/CryptoOps/contract.py:45
    // return result_k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_r1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_r1:
    // tests/artifacts/CryptoOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_ecdsa_verify_r1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:49
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:50
    // result_r1 = op.ecdsa_verify(op.ECDSA.Secp256r1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256r1
    // tests/artifacts/CryptoOps/contract.py:51
    // return result_r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_k1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_k1:
    // tests/artifacts/CryptoOps/contract.py:53-56
    // @arc4.abimethod()
    // def verify_ecdsa_recover_k1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:57
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:58
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256k1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_r1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_r1:
    // tests/artifacts/CryptoOps/contract.py:60-63
    // @arc4.abimethod()
    // def verify_ecdsa_recover_r1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:67
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:68
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256r1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_k1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_k1:
    // tests/artifacts/CryptoOps/contract.py:70-71
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_k1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:72
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:73
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256k1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_r1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_r1:
    // tests/artifacts/CryptoOps/contract.py:75-76
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_r1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:77
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:78
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256r1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_vrf_verify(a: bytes, b: bytes, c: bytes) -> bytes, uint64:
verify_vrf_verify:
    // tests/artifacts/CryptoOps/contract.py:80-81
    // @arc4.abimethod()
    // def verify_vrf_verify(self, a: Bytes, b: Bytes, c: Bytes) -> tuple[Bytes, bool]:
    proto 3 2
    // tests/artifacts/CryptoOps/contract.py:82
    // ensure_budget(5700, OpUpFeeSource.GroupCredit)
    pushint 5700 // 5700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:83
    // result = op.vrf_verify(op.VrfVerify.VrfAlgorand, a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    vrf_verify VrfAlgorand
    // tests/artifacts/CryptoOps/contract.py:84
    // return result
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 4 3000
    bytecblock 0x151f7c75 0x00 0x0004 0x068101
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@18
    pushbytess 0x3456c4c3 0xe8442b84 0x65f567aa 0x258455b1 0x35af0f38 0x6582c997 0x6298ffbb 0x3885b54f 0x2164e0bf 0x755b79a5 0xf06bb077 0x133f8ccc 0x2f7c68a9 // method "verify_sha256(byte[],uint64)byte[]", method "verify_sha3_256(byte[],uint64)byte[]", method "verify_keccak_256(byte[],uint64)byte[]", method "verify_sha512_256(byte[],uint64)byte[]", method "verify_ed25519verify(byte[],byte[],byte[])bool", method "verify_ed25519verify_bare(byte[],byte[],byte[])bool", method "verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_decompress_k1(byte[])(byte[],byte[])", method "verify_ecdsa_decompress_r1(byte[])(byte[],byte[])", method "verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)"
    txna ApplicationArgs 0
    match main_verify_sha256_route@3 main_verify_sha3_256_route@4 main_verify_keccak_256_route@5 main_verify_sha512_256_route@6 main_verify_ed25519verify_route@7 main_verify_ed25519verify_bare_route@8 main_verify_ecdsa_verify_k1_route@9 main_verify_ecdsa_verify_r1_route@10 main_verify_ecdsa_recover_k1_route@11 main_verify_ecdsa_recover_r1_route@12 main_verify_ecdsa_decompress_k1_route@13 main_verify_ecdsa_decompress_r1_route@14 main_verify_vrf_verify_route@15

main_after_if_else@22:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    intc_0 // 0
    return

main_verify_vrf_verify_route@15:
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    callsub verify_vrf_verify
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    pushbytes 0x0003
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_r1_route@14:
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_k1_route@13:
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_r1_route@12:
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_k1_route@11:
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_r1_route@10:
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_r1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_k1_route@9:
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_k1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_bare_route@8:
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    callsub verify_ed25519verify_bare
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_route@7:
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    callsub verify_ed25519verify
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha512_256_route@6:
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    callsub verify_sha512_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_keccak_256_route@5:
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    callsub verify_keccak_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha3_256_route@4:
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    callsub verify_sha3_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha256_route@3:
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_sha256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_bare_routing@18:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@22
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.util.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
ensure_budget:
    proto 2 0
    frame_dig -2
    pushint 10 // 10
    +

ensure_budget_while_top@1:
    frame_dig 0
    global OpcodeBudget
    >
    bz ensure_budget_after_while@7
    itxn_begin
    pushint 6 // appl
    itxn_field TypeEnum
    pushint 5 // DeleteApplication
    itxn_field OnCompletion
    bytec_3 // 0x068101
    itxn_field ApprovalProgram
    bytec_3 // 0x068101
    itxn_field ClearStateProgram
    frame_dig -1
    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4

ensure_budget_switch_case_next@6:
    itxn_submit
    b ensure_budget_while_top@1

ensure_budget_switch_case_1@4:
    global MinTxnFee
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_switch_case_0@3:
    intc_0 // 0
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_after_while@7:
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha256(a: bytes, pad_size: uint64) -> bytes:
verify_sha256:
    // tests/artifacts/CryptoOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_sha256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:7
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:8
    // result = op.sha256(a)
    sha256
    // tests/artifacts/CryptoOps/contract.py:9
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha3_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha3_256:
    // tests/artifacts/CryptoOps/contract.py:11-12
    // @arc4.abimethod()
    // def verify_sha3_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:13
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:14
    // result = op.sha3_256(a)
    sha3_256
    // tests/artifacts/CryptoOps/contract.py:15
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_keccak_256(a: bytes, pad_size: uint64) -> bytes:
verify_keccak_256:
    // tests/artifacts/CryptoOps/contract.py:17-18
    // @arc4.abimethod()
    // def verify_keccak_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:19
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:20
    // result = op.keccak256(a)
    keccak256
    // tests/artifacts/CryptoOps/contract.py:21
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha512_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha512_256:
    // tests/artifacts/CryptoOps/contract.py:23-24
    // @arc4.abimethod()
    // def verify_sha512_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:25
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:26
    // result = op.sha512_256(a)
    sha512_256
    // tests/artifacts/CryptoOps/contract.py:27
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify:
    // tests/artifacts/CryptoOps/contract.py:29-30
    // @arc4.abimethod()
    // def verify_ed25519verify(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:31
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:32
    // result = op.ed25519verify(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify
    // tests/artifacts/CryptoOps/contract.py:33
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify_bare:
    // tests/artifacts/CryptoOps/contract.py:35-36
    // @arc4.abimethod()
    // def verify_ed25519verify_bare(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:37
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:38
    // result = op.ed25519verify_bare(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify_bare
    // tests/artifacts/CryptoOps/contract.py:39
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_k1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_k1:
    // tests/artifacts/CryptoOps/contract.py:41-42
    // @arc4.abimethod()
    // def verify_ecdsa_verify_k1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:43
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:44
    // result_k1 = op.ecdsa_verify(op.ECDSA.Secp256k1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256k1
    // tests/artifacts/CryptoOps/contract.py:45
    // return result_k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_r1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_r1:
    // tests/artifacts/CryptoOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_ecdsa_verify_r1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:49
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:50
    // result_r1 = op.ecdsa_verify(op.ECDSA.Secp256r1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256r1
    // tests/artifacts/CryptoOps/contract.py:51
    // return result_r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_k1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_k1:
    // tests/artifacts/CryptoOps/contract.py:53-56
    // @arc4.abimethod()
    // def verify_ecdsa_recover_k1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:57
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:58
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256k1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_r1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_r1:
    // tests/artifacts/CryptoOps/contract.py:60-63
    // @arc4.abimethod()
    // def verify_ecdsa_recover_r1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:67
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:68
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256r1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_k1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_k1:
    // tests/artifacts/CryptoOps/contract.py:70-71
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_k1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:72
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:73
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256k1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_r1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_r1:
    // tests/artifacts/CryptoOps/contract.py:75-76
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_r1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:77
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:78
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256r1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_vrf_verify(a: bytes, b: bytes, c: bytes) -> bytes, uint64:
verify_vrf_verify:
    // tests/artifacts/CryptoOps/contract.py:80-81
    // @arc4.abimethod()
    // def verify_vrf_verify(self, a: Bytes, b: Bytes, c: Bytes) -> tuple[Bytes, bool]:
    proto 3 2
    // tests/artifacts/CryptoOps/contract.py:82
    // ensure_budget(5700, OpUpFeeSource.GroupCredit)
    pushint 5700 // 5700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:83
    // result = op.vrf_verify(op.VrfVerify.VrfAlgorand, a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    vrf_verify VrfAlgorand
    // tests/artifacts/CryptoOps/contract.py:84
    // return result
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc56.json b/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc56.json
index f74eedfd..da104f05 100644
--- a/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc56.json
+++ b/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc56.json
@@ -460,19 +460,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 4 3000
    bytecblock 0x151f7c75 0x00 0x0004 0x068101
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@18
    pushbytess 0x3456c4c3 0xe8442b84 0x65f567aa 0x258455b1 0x35af0f38 0x6582c997 0x6298ffbb 0x3885b54f 0x2164e0bf 0x755b79a5 0xf06bb077 0x133f8ccc 0x2f7c68a9 // method "verify_sha256(byte[],uint64)byte[]", method "verify_sha3_256(byte[],uint64)byte[]", method "verify_keccak_256(byte[],uint64)byte[]", method "verify_sha512_256(byte[],uint64)byte[]", method "verify_ed25519verify(byte[],byte[],byte[])bool", method "verify_ed25519verify_bare(byte[],byte[],byte[])bool", method "verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_decompress_k1(byte[])(byte[],byte[])", method "verify_ecdsa_decompress_r1(byte[])(byte[],byte[])", method "verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)"
    txna ApplicationArgs 0
    match main_verify_sha256_route@3 main_verify_sha3_256_route@4 main_verify_keccak_256_route@5 main_verify_sha512_256_route@6 main_verify_ed25519verify_route@7 main_verify_ed25519verify_bare_route@8 main_verify_ecdsa_verify_k1_route@9 main_verify_ecdsa_verify_r1_route@10 main_verify_ecdsa_recover_k1_route@11 main_verify_ecdsa_recover_r1_route@12 main_verify_ecdsa_decompress_k1_route@13 main_verify_ecdsa_decompress_r1_route@14 main_verify_vrf_verify_route@15

main_after_if_else@22:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    intc_0 // 0
    return

main_verify_vrf_verify_route@15:
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    callsub verify_vrf_verify
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    pushbytes 0x0003
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_r1_route@14:
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_k1_route@13:
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_r1_route@12:
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_k1_route@11:
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_r1_route@10:
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_r1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_k1_route@9:
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_k1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_bare_route@8:
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    callsub verify_ed25519verify_bare
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_route@7:
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    callsub verify_ed25519verify
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha512_256_route@6:
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    callsub verify_sha512_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_keccak_256_route@5:
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    callsub verify_keccak_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha3_256_route@4:
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    callsub verify_sha3_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha256_route@3:
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_sha256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_bare_routing@18:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@22
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.util.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
ensure_budget:
    proto 2 0
    frame_dig -2
    pushint 10 // 10
    +

ensure_budget_while_top@1:
    frame_dig 0
    global OpcodeBudget
    >
    bz ensure_budget_after_while@7
    itxn_begin
    pushint 6 // appl
    itxn_field TypeEnum
    pushint 5 // DeleteApplication
    itxn_field OnCompletion
    bytec_3 // 0x068101
    itxn_field ApprovalProgram
    bytec_3 // 0x068101
    itxn_field ClearStateProgram
    frame_dig -1
    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4

ensure_budget_switch_case_next@6:
    itxn_submit
    b ensure_budget_while_top@1

ensure_budget_switch_case_1@4:
    global MinTxnFee
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_switch_case_0@3:
    intc_0 // 0
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_after_while@7:
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha256(a: bytes, pad_size: uint64) -> bytes:
verify_sha256:
    // tests/artifacts/CryptoOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_sha256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:7
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:8
    // result = op.sha256(a)
    sha256
    // tests/artifacts/CryptoOps/contract.py:9
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha3_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha3_256:
    // tests/artifacts/CryptoOps/contract.py:11-12
    // @arc4.abimethod()
    // def verify_sha3_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:13
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:14
    // result = op.sha3_256(a)
    sha3_256
    // tests/artifacts/CryptoOps/contract.py:15
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_keccak_256(a: bytes, pad_size: uint64) -> bytes:
verify_keccak_256:
    // tests/artifacts/CryptoOps/contract.py:17-18
    // @arc4.abimethod()
    // def verify_keccak_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:19
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:20
    // result = op.keccak256(a)
    keccak256
    // tests/artifacts/CryptoOps/contract.py:21
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha512_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha512_256:
    // tests/artifacts/CryptoOps/contract.py:23-24
    // @arc4.abimethod()
    // def verify_sha512_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:25
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:26
    // result = op.sha512_256(a)
    sha512_256
    // tests/artifacts/CryptoOps/contract.py:27
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify:
    // tests/artifacts/CryptoOps/contract.py:29-30
    // @arc4.abimethod()
    // def verify_ed25519verify(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:31
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:32
    // result = op.ed25519verify(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify
    // tests/artifacts/CryptoOps/contract.py:33
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify_bare:
    // tests/artifacts/CryptoOps/contract.py:35-36
    // @arc4.abimethod()
    // def verify_ed25519verify_bare(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:37
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:38
    // result = op.ed25519verify_bare(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify_bare
    // tests/artifacts/CryptoOps/contract.py:39
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_k1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_k1:
    // tests/artifacts/CryptoOps/contract.py:41-42
    // @arc4.abimethod()
    // def verify_ecdsa_verify_k1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:43
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:44
    // result_k1 = op.ecdsa_verify(op.ECDSA.Secp256k1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256k1
    // tests/artifacts/CryptoOps/contract.py:45
    // return result_k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_r1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_r1:
    // tests/artifacts/CryptoOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_ecdsa_verify_r1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:49
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:50
    // result_r1 = op.ecdsa_verify(op.ECDSA.Secp256r1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256r1
    // tests/artifacts/CryptoOps/contract.py:51
    // return result_r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_k1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_k1:
    // tests/artifacts/CryptoOps/contract.py:53-56
    // @arc4.abimethod()
    // def verify_ecdsa_recover_k1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:57
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:58
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256k1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_r1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_r1:
    // tests/artifacts/CryptoOps/contract.py:60-63
    // @arc4.abimethod()
    // def verify_ecdsa_recover_r1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:67
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:68
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256r1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_k1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_k1:
    // tests/artifacts/CryptoOps/contract.py:70-71
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_k1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:72
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:73
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256k1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_r1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_r1:
    // tests/artifacts/CryptoOps/contract.py:75-76
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_r1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:77
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:78
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256r1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_vrf_verify(a: bytes, b: bytes, c: bytes) -> bytes, uint64:
verify_vrf_verify:
    // tests/artifacts/CryptoOps/contract.py:80-81
    // @arc4.abimethod()
    // def verify_vrf_verify(self, a: Bytes, b: Bytes, c: Bytes) -> tuple[Bytes, bool]:
    proto 3 2
    // tests/artifacts/CryptoOps/contract.py:82
    // ensure_budget(5700, OpUpFeeSource.GroupCredit)
    pushint 5700 // 5700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:83
    // result = op.vrf_verify(op.VrfVerify.VrfAlgorand, a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    vrf_verify VrfAlgorand
    // tests/artifacts/CryptoOps/contract.py:84
    // return result
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 0 1 4 3000
    bytecblock 0x151f7c75 0x00 0x0004 0x068101
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@18
    pushbytess 0x3456c4c3 0xe8442b84 0x65f567aa 0x258455b1 0x35af0f38 0x6582c997 0x6298ffbb 0x3885b54f 0x2164e0bf 0x755b79a5 0xf06bb077 0x133f8ccc 0x2f7c68a9 // method "verify_sha256(byte[],uint64)byte[]", method "verify_sha3_256(byte[],uint64)byte[]", method "verify_keccak_256(byte[],uint64)byte[]", method "verify_sha512_256(byte[],uint64)byte[]", method "verify_ed25519verify(byte[],byte[],byte[])bool", method "verify_ed25519verify_bare(byte[],byte[],byte[])bool", method "verify_ecdsa_verify_k1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_verify_r1(byte[],byte[],byte[],byte[],byte[])bool", method "verify_ecdsa_recover_k1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_recover_r1(byte[],uint64,byte[],byte[])(byte[],byte[])", method "verify_ecdsa_decompress_k1(byte[])(byte[],byte[])", method "verify_ecdsa_decompress_r1(byte[])(byte[],byte[])", method "verify_vrf_verify(byte[],byte[],byte[])(byte[],bool)"
    txna ApplicationArgs 0
    match main_verify_sha256_route@3 main_verify_sha3_256_route@4 main_verify_keccak_256_route@5 main_verify_sha512_256_route@6 main_verify_ed25519verify_route@7 main_verify_ed25519verify_bare_route@8 main_verify_ecdsa_verify_k1_route@9 main_verify_ecdsa_verify_r1_route@10 main_verify_ecdsa_recover_k1_route@11 main_verify_ecdsa_recover_r1_route@12 main_verify_ecdsa_decompress_k1_route@13 main_verify_ecdsa_decompress_r1_route@14 main_verify_vrf_verify_route@15

main_after_if_else@22:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    intc_0 // 0
    return

main_verify_vrf_verify_route@15:
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    callsub verify_vrf_verify
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 3
    setbit
    pushbytes 0x0003
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_r1_route@14:
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_decompress_k1_route@13:
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    callsub verify_ecdsa_decompress_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_r1_route@12:
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_r1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_recover_k1_route@11:
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    callsub verify_ecdsa_recover_k1
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    dup
    len
    intc_2 // 4
    +
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    itob
    extract 6 2
    bytec_2 // 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_r1_route@10:
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_r1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ecdsa_verify_k1_route@9:
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    callsub verify_ecdsa_verify_k1
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_bare_route@8:
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    callsub verify_ed25519verify_bare
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_ed25519verify_route@7:
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    callsub verify_ed25519verify
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha512_256_route@6:
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    callsub verify_sha512_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_keccak_256_route@5:
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    callsub verify_keccak_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha3_256_route@4:
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    callsub verify_sha3_256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_verify_sha256_route@3:
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_sha256
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_bare_routing@18:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@22
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.util.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
ensure_budget:
    proto 2 0
    frame_dig -2
    pushint 10 // 10
    +

ensure_budget_while_top@1:
    frame_dig 0
    global OpcodeBudget
    >
    bz ensure_budget_after_while@7
    itxn_begin
    pushint 6 // appl
    itxn_field TypeEnum
    pushint 5 // DeleteApplication
    itxn_field OnCompletion
    bytec_3 // 0x068101
    itxn_field ApprovalProgram
    bytec_3 // 0x068101
    itxn_field ClearStateProgram
    frame_dig -1
    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4

ensure_budget_switch_case_next@6:
    itxn_submit
    b ensure_budget_while_top@1

ensure_budget_switch_case_1@4:
    global MinTxnFee
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_switch_case_0@3:
    intc_0 // 0
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_after_while@7:
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha256(a: bytes, pad_size: uint64) -> bytes:
verify_sha256:
    // tests/artifacts/CryptoOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_sha256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:7
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:8
    // result = op.sha256(a)
    sha256
    // tests/artifacts/CryptoOps/contract.py:9
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha3_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha3_256:
    // tests/artifacts/CryptoOps/contract.py:11-12
    // @arc4.abimethod()
    // def verify_sha3_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:13
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:14
    // result = op.sha3_256(a)
    sha3_256
    // tests/artifacts/CryptoOps/contract.py:15
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_keccak_256(a: bytes, pad_size: uint64) -> bytes:
verify_keccak_256:
    // tests/artifacts/CryptoOps/contract.py:17-18
    // @arc4.abimethod()
    // def verify_keccak_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:19
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:20
    // result = op.keccak256(a)
    keccak256
    // tests/artifacts/CryptoOps/contract.py:21
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_sha512_256(a: bytes, pad_size: uint64) -> bytes:
verify_sha512_256:
    // tests/artifacts/CryptoOps/contract.py:23-24
    // @arc4.abimethod()
    // def verify_sha512_256(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/CryptoOps/contract.py:25
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/CryptoOps/contract.py:26
    // result = op.sha512_256(a)
    sha512_256
    // tests/artifacts/CryptoOps/contract.py:27
    // return result
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify:
    // tests/artifacts/CryptoOps/contract.py:29-30
    // @arc4.abimethod()
    // def verify_ed25519verify(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:31
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:32
    // result = op.ed25519verify(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify
    // tests/artifacts/CryptoOps/contract.py:33
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ed25519verify_bare(a: bytes, b: bytes, c: bytes) -> bytes:
verify_ed25519verify_bare:
    // tests/artifacts/CryptoOps/contract.py:35-36
    // @arc4.abimethod()
    // def verify_ed25519verify_bare(self, a: Bytes, b: Bytes, c: Bytes) -> arc4.Bool:
    proto 3 1
    // tests/artifacts/CryptoOps/contract.py:37
    // ensure_budget(1900, OpUpFeeSource.GroupCredit)
    pushint 1900 // 1900
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:38
    // result = op.ed25519verify_bare(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ed25519verify_bare
    // tests/artifacts/CryptoOps/contract.py:39
    // return arc4.Bool(result)
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_k1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_k1:
    // tests/artifacts/CryptoOps/contract.py:41-42
    // @arc4.abimethod()
    // def verify_ecdsa_verify_k1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:43
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:44
    // result_k1 = op.ecdsa_verify(op.ECDSA.Secp256k1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256k1
    // tests/artifacts/CryptoOps/contract.py:45
    // return result_k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_verify_r1(a: bytes, b: bytes, c: bytes, d: bytes, e: bytes) -> uint64:
verify_ecdsa_verify_r1:
    // tests/artifacts/CryptoOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_ecdsa_verify_r1(self, a: Bytes, b: Bytes, c: Bytes, d: Bytes, e: Bytes) -> bool:
    proto 5 1
    // tests/artifacts/CryptoOps/contract.py:49
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:50
    // result_r1 = op.ecdsa_verify(op.ECDSA.Secp256r1, a, b, c, d, e)
    frame_dig -5
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_verify Secp256r1
    // tests/artifacts/CryptoOps/contract.py:51
    // return result_r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_k1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_k1:
    // tests/artifacts/CryptoOps/contract.py:53-56
    // @arc4.abimethod()
    // def verify_ecdsa_recover_k1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:57
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:58
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256k1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_recover_r1(a: bytes, b: uint64, c: bytes, d: bytes) -> bytes, bytes:
verify_ecdsa_recover_r1:
    // tests/artifacts/CryptoOps/contract.py:60-63
    // @arc4.abimethod()
    // def verify_ecdsa_recover_r1(
    //     self, a: Bytes, b: UInt64, c: Bytes, d: Bytes
    // ) -> tuple[Bytes, Bytes]:
    proto 4 2
    // tests/artifacts/CryptoOps/contract.py:67
    // ensure_budget(3000, OpUpFeeSource.GroupCredit)
    intc_3 // 3000
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:68
    // return op.ecdsa_pk_recover(op.ECDSA.Secp256r1, a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    ecdsa_pk_recover Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_k1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_k1:
    // tests/artifacts/CryptoOps/contract.py:70-71
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_k1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:72
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:73
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256k1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256k1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_ecdsa_decompress_r1(a: bytes) -> bytes, bytes:
verify_ecdsa_decompress_r1:
    // tests/artifacts/CryptoOps/contract.py:75-76
    // @arc4.abimethod()
    // def verify_ecdsa_decompress_r1(self, a: Bytes) -> tuple[Bytes, Bytes]:
    proto 1 2
    // tests/artifacts/CryptoOps/contract.py:77
    // ensure_budget(700, OpUpFeeSource.GroupCredit)
    pushint 700 // 700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:78
    // return op.ecdsa_pk_decompress(op.ECDSA.Secp256r1, a)
    frame_dig -1
    ecdsa_pk_decompress Secp256r1
    retsub


// tests.artifacts.CryptoOps.contract.CryptoOpsContract.verify_vrf_verify(a: bytes, b: bytes, c: bytes) -> bytes, uint64:
verify_vrf_verify:
    // tests/artifacts/CryptoOps/contract.py:80-81
    // @arc4.abimethod()
    // def verify_vrf_verify(self, a: Bytes, b: Bytes, c: Bytes) -> tuple[Bytes, bool]:
    proto 3 2
    // tests/artifacts/CryptoOps/contract.py:82
    // ensure_budget(5700, OpUpFeeSource.GroupCredit)
    pushint 5700 // 5700
    intc_0 // 0
    callsub ensure_budget
    // tests/artifacts/CryptoOps/contract.py:83
    // result = op.vrf_verify(op.VrfVerify.VrfAlgorand, a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    vrf_verify VrfAlgorand
    // tests/artifacts/CryptoOps/contract.py:84
    // return result
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "CiAEAAEEuBcmBAQVH3x1AQACAAQDBoEBMRtBAtuCDQQ0VsTDBOhEK4QEZfVnqgQlhFWxBDWvDzgEZYLJlwRimP+7BDiFtU8EIWTgvwR1W3mlBPBrsHcEEz+MzAQvfGipNhoAjg0CVwI1AhMB8QHPAa0BegFHAPwAsQB2ADsAAiJDMRkURDEYRDYaAVcCADYaAlcCADYaA1cCAIgDc0sBFRZXBgJPAlApIk8DVIACAANMUExQKExQsCNDMRkURDEYRDYaAVcCAIgDN0sBFRZXBgJPAlBLARUWVwYCTwJQSwEVJAgWVwYCKkxQTwJQTFAoTFCwI0MxGRREMRhENhoBVwIAiALtSwEVFlcGAk8CUEsBFRZXBgJPAlBLARUkCBZXBgIqTFBPAlBMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgIXNhoDVwIANhoEVwIAiAKPSwEVFlcGAk8CUEsBFRZXBgJPAlBLARUkCBZXBgIqTFBPAlBMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgIXNhoDVwIANhoEVwIAiAIxSwEVFlcGAk8CUEsBFRZXBgJPAlBLARUkCBZXBgIqTFBPAlBMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgJXAgA2GgNXAgA2GgRXAgA2GgVXAgCIAckpIk8CVChMULAjQzEZFEQxGEQ2GgFXAgA2GgJXAgA2GgNXAgA2GgRXAgA2GgVXAgCIAYEpIk8CVChMULAjQzEZFEQxGEQ2GgFXAgA2GgJXAgA2GgNXAgCIAUMoTFCwI0MxGRREMRhENhoBVwIANhoCVwIANhoDVwIAiAEKKExQsCNDMRkURDEYRDYaAVcCADYaAheIAOJJFRZXBgJMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgIXiACySRUWVwYCTFAoTFCwI0MxGRREMRhENhoBVwIANhoCF4gAgkkVFlcGAkxQKExQsCNDMRkURDEYRDYaAVcCADYaAheIAFJJFRZXBgJMUChMULAjQzEZQP2CMRgURCNDigIAi/6BCgiLADIMDUEAKLGBBrIQgQWyGSuyHiuyH4v/jQIACwAEs0L/3TIAsgFC//UisgFC/++JigIBi/+vi/5QSYz+AYmKAgGL/6+L/lBJjP6YiYoCAYv/r4v+UEmM/gKJigIBi/+vi/5QSYz+A4mKAwGB7A4iiP+Fi/2L/ov/BCkiTwJUiYoDAYHsDiKI/26L/Yv+i/+EKSJPAlSJigUBJSKI/1mL+4v8i/2L/ov/BQCJigUBJSKI/0SL+4v8i/2L/ov/BQGJigQCJSKI/y+L/Iv9i/6L/wcAiYoEAiUiiP8ci/yL/Yv+i/8HAYmKAQKBvAUiiP8Hi/8GAImKAQKBvAUiiP74i/8GAYmKAwKBxCwiiP7pi/2L/ov/0ACJ",
+        "approval": "CiAEAAEEuBcmBAQVH3x1AQACAAQDBoEBMRtBAtuCDQQ0VsTDBOhEK4QEZfVnqgQlhFWxBDWvDzgEZYLJlwRimP+7BDiFtU8EIWTgvwR1W3mlBPBrsHcEEz+MzAQvfGipNhoAjg0CVwI1AhMB8QHPAa0BegFHAPwAsQB2ADsAAiJDMRkURDEYRDYaAVcCADYaAlcCADYaA1cCAIgDc0sBFRZXBgJPAlApIk8DVIACAANMUExQKExQsCNDMRkURDEYRDYaAVcCAIgDN0sBFRZXBgJPAlBJFSQISwIVFlcGAk8DUEwWVwYCKkxQTwJQTFAoTFCwI0MxGRREMRhENhoBVwIAiALtSwEVFlcGAk8CUEkVJAhLAhUWVwYCTwNQTBZXBgIqTFBPAlBMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgIXNhoDVwIANhoEVwIAiAKPSwEVFlcGAk8CUEkVJAhLAhUWVwYCTwNQTBZXBgIqTFBPAlBMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgIXNhoDVwIANhoEVwIAiAIxSwEVFlcGAk8CUEkVJAhLAhUWVwYCTwNQTBZXBgIqTFBPAlBMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgJXAgA2GgNXAgA2GgRXAgA2GgVXAgCIAckpIk8CVChMULAjQzEZFEQxGEQ2GgFXAgA2GgJXAgA2GgNXAgA2GgRXAgA2GgVXAgCIAYEpIk8CVChMULAjQzEZFEQxGEQ2GgFXAgA2GgJXAgA2GgNXAgCIAUMoTFCwI0MxGRREMRhENhoBVwIANhoCVwIANhoDVwIAiAEKKExQsCNDMRkURDEYRDYaAVcCADYaAheIAOJJFRZXBgJMUChMULAjQzEZFEQxGEQ2GgFXAgA2GgIXiACySRUWVwYCTFAoTFCwI0MxGRREMRhENhoBVwIANhoCF4gAgkkVFlcGAkxQKExQsCNDMRkURDEYRDYaAVcCADYaAheIAFJJFRZXBgJMUChMULAjQzEZQP2CMRgURCNDigIAi/6BCgiLADIMDUEAKLGBBrIQgQWyGSuyHiuyH4v/jQIACwAEs0L/3TIAsgFC//UisgFC/++JigIBi/+vi/5QSYz+AYmKAgGL/6+L/lBJjP6YiYoCAYv/r4v+UEmM/gKJigIBi/+vi/5QSYz+A4mKAwGB7A4iiP+Fi/2L/ov/BCkiTwJUiYoDAYHsDiKI/26L/Yv+i/+EKSJPAlSJigUBJSKI/1mL+4v8i/2L/ov/BQCJigUBJSKI/0SL+4v8i/2L/ov/BQGJigQCJSKI/y+L/Iv9i/6L/wcAiYoEAiUiiP8ci/yL/Yv+i/8HAYmKAQKBvAUiiP8Hi/8GAImKAQKBvAUiiP74i/8GAYmKAwKBxCwiiP7pi/2L/ov/0ACJ",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc56.json b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc56.json
index 958ac8bd..5fb0a8ad 100644
--- a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc56.json
+++ b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc56.json
@@ -108,8 +108,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal
index 9ea557c3..dd2c6d38 100644
--- a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal
+++ b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal
@@ -776,16 +776,12 @@ main_verify_divmodw_route@12:
     itob
     uncover 3
     itob
-    uncover 3
-    itob
-    uncover 3
-    itob
-    uncover 3
-    uncover 3
     concat
     uncover 2
+    itob
     concat
     swap
+    itob
     concat
     bytec_0 // 0x151f7c75
     swap
diff --git a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json
index b23b43fe..a0d96ebf 100644
--- a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json
+++ b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json
@@ -187,7 +187,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@42
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a 0x66dd7f96 0x4d9eceb2 0x19ba70ee // method "verify_addw(uint64,uint64)(uint64,uint64)", method "verify_base64_decode_standard(byte[])byte[]", method "verify_base64_decode_url(byte[])byte[]", method "verify_bytes_bitlen(byte[],uint64)uint64", method "verify_uint64_bitlen(uint64)uint64", method "verify_bsqrt(byte[])byte[]", method "verify_btoi(byte[])uint64", method "verify_bzero(uint64)byte[]", method "verify_concat(byte[],byte[],uint64,uint64)byte[]", method "verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)", method "verify_divw(uint64,uint64,uint64)uint64", method "verify_err()void", method "verify_exp(uint64,uint64)uint64", method "verify_expw(uint64,uint64)(uint64,uint64)", method "verify_extract(byte[],uint64,uint64)byte[]", method "verify_extract_from_2(byte[])byte[]", method "verify_extract_uint16(byte[],uint64)uint64", method "verify_extract_uint32(byte[],uint64)uint64", method "verify_extract_uint64(byte[],uint64)uint64", method "verify_getbit_bytes(byte[],uint64)uint64", method "verify_getbit_uint64(uint64,uint64)uint64", method "verify_getbyte(byte[],uint64)uint64", method "verify_itob(uint64)byte[]", method "verify_mulw(uint64,uint64)(uint64,uint64)", method "verify_replace(byte[],uint64,byte[])byte[]", method "verify_select_bytes(byte[],byte[],uint64)byte[]", method "verify_select_uint64(uint64,uint64,uint64)uint64", method "verify_setbit_bytes(byte[],uint64,uint64)byte[]", method "verify_setbit_uint64(uint64,uint64,uint64)uint64", method "verify_setbyte(byte[],uint64,uint64)byte[]", method "verify_shl(uint64,uint64)uint64", method "verify_shr(uint64,uint64)uint64", method "verify_sqrt(uint64)uint64", method "verify_substring(byte[],uint64,uint64)byte[]", method "verify_json_ref_string(byte[],byte[])byte[]", method "verify_json_ref_uint64(byte[],byte[])uint64", method "verify_json_ref_object(byte[],byte[])byte[]"
    txna ApplicationArgs 0
    match main_verify_addw_route@3 main_verify_base64_decode_standard_route@4 main_verify_base64_decode_url_route@5 main_verify_bytes_bitlen_route@6 main_verify_uint64_bitlen_route@7 main_verify_bsqrt_route@8 main_verify_btoi_route@9 main_verify_bzero_route@10 main_verify_concat_route@11 main_verify_divmodw_route@12 main_verify_divw_route@13 main_verify_err_route@14 main_verify_exp_route@15 main_verify_expw_route@16 main_verify_extract_route@17 main_verify_extract_from_2_route@18 main_verify_extract_uint16_route@19 main_verify_extract_uint32_route@20 main_verify_extract_uint64_route@21 main_verify_getbit_bytes_route@22 main_verify_getbit_uint64_route@23 main_verify_getbyte_route@24 main_verify_itob_route@25 main_verify_mulw_route@26 main_verify_replace_route@27 main_verify_select_bytes_route@28 main_verify_select_uint64_route@29 main_verify_setbit_bytes_route@30 main_verify_setbit_uint64_route@31 main_verify_setbyte_route@32 main_verify_shl_route@33 main_verify_shr_route@34 main_verify_sqrt_route@35 main_verify_substring_route@36 main_verify_json_ref_string_route@37 main_verify_json_ref_uint64_route@38 main_verify_json_ref_object_route@39

main_after_if_else@46:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    pushint 0 // 0
    return

main_verify_json_ref_object_route@39:
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    callsub verify_json_ref_object
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_uint64_route@38:
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    callsub verify_json_ref_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_string_route@37:
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    callsub verify_json_ref_string
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_substring_route@36:
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_sqrt_route@35:
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shr_route@34:
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shl_route@33:
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbyte_route@32:
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_uint64_route@31:
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_bytes_route@30:
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_uint64_route@29:
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_bytes_route@28:
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_replace_route@27:
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_mulw_route@26:
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_itob_route@25:
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbyte_route@24:
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_uint64_route@23:
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_bytes_route@22:
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint64_route@21:
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint32_route@20:
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint16_route@19:
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_from_2_route@18:
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_route@17:
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_expw_route@16:
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_exp_route@15:
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_err_route@14:
    // tests/artifacts/MiscellaneousOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:69
    // op.err()
    err

main_verify_divw_route@13:
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_divmodw_route@12:
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_divmodw
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    uncover 3
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_concat_route@11:
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bzero_route@10:
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_btoi_route@9:
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bsqrt_route@8:
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_bitlen_route@7:
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_bitlen_route@6:
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_url_route@5:
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_standard_route@4:
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    callsub verify_base64_decode_standard
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_addw_route@3:
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@42:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@46
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/MiscellaneousOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_addw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:7
    // result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/MiscellaneousOps/contract.py:8
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/MiscellaneousOps/contract.py:10-11
    // @arc4.abimethod()
    // def verify_base64_decode_standard(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:12
    // result = op.base64_decode(op.Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:13
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/MiscellaneousOps/contract.py:15-16
    // @arc4.abimethod()
    // def verify_base64_decode_url(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:17
    // result = op.base64_decode(op.Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:18
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:20-21
    // @arc4.abimethod()
    // def verify_bytes_bitlen(self, a: Bytes, pad_a_size: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:22
    // a = op.bzero(pad_a_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/MiscellaneousOps/contract.py:23
    // result = op.bitlen(a)
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:24
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:26-27
    // @arc4.abimethod()
    // def verify_uint64_bitlen(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:28
    // result = op.bitlen(a)
    frame_dig -1
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:29
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_bsqrt(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:34
    // result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/MiscellaneousOps/contract.py:35
    // return result.bytes
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/MiscellaneousOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_btoi(self, a: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:39
    // result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:40
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/MiscellaneousOps/contract.py:42-43
    // @arc4.abimethod()
    // def verify_bzero(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:44
    // result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/MiscellaneousOps/contract.py:45
    // return op.sha256(result)
    sha256
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/MiscellaneousOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_concat(self, a: Bytes, b: Bytes, pad_a_size: UInt64, pad_b_size: UInt64) -> Bytes:
    proto 4 1
    // tests/artifacts/MiscellaneousOps/contract.py:49
    // a = op.bzero(pad_a_size) + a
    frame_dig -2
    bzero
    frame_dig -4
    concat
    frame_bury -4
    // tests/artifacts/MiscellaneousOps/contract.py:50
    // b = op.bzero(pad_b_size) + b
    frame_dig -1
    bzero
    frame_dig -3
    concat
    frame_bury -3
    // tests/artifacts/MiscellaneousOps/contract.py:51
    // result = a + b
    frame_dig -4
    frame_dig -3
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:52
    // result = op.sha256(result)
    sha256
    // tests/artifacts/MiscellaneousOps/contract.py:53
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/MiscellaneousOps/contract.py:55-58
    // @arc4.abimethod()
    // def verify_divmodw(
    //     self, a: UInt64, b: UInt64, c: UInt64, d: UInt64
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    // tests/artifacts/MiscellaneousOps/contract.py:59
    // result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/MiscellaneousOps/contract.py:60
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/MiscellaneousOps/contract.py:62-63
    // @arc4.abimethod()
    // def verify_divw(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:64
    // result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/MiscellaneousOps/contract.py:65
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/MiscellaneousOps/contract.py:71-72
    // @arc4.abimethod()
    // def verify_exp(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:73
    // result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/MiscellaneousOps/contract.py:74
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/MiscellaneousOps/contract.py:76-77
    // @arc4.abimethod()
    // def verify_expw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:78
    // result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/MiscellaneousOps/contract.py:79
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/MiscellaneousOps/contract.py:81-82
    // @arc4.abimethod()
    // def verify_extract(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:83
    // result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/MiscellaneousOps/contract.py:84
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/MiscellaneousOps/contract.py:86-87
    // @arc4.abimethod()
    // def verify_extract_from_2(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:88
    // result = op.extract(a, 2, 0)
    frame_dig -1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:89
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/MiscellaneousOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_extract_uint16(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:93
    // result = op.extract_uint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/MiscellaneousOps/contract.py:94
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/MiscellaneousOps/contract.py:96-97
    // @arc4.abimethod()
    // def verify_extract_uint32(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:98
    // result = op.extract_uint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/MiscellaneousOps/contract.py:99
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:101-102
    // @arc4.abimethod()
    // def verify_extract_uint64(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:103
    // result = op.extract_uint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/MiscellaneousOps/contract.py:104
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:106-107
    // @arc4.abimethod()
    // def verify_getbit_bytes(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:108
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:109
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:111-112
    // @arc4.abimethod()
    // def verify_getbit_uint64(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:113
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:114
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:116-117
    // @arc4.abimethod()
    // def verify_getbyte(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:118
    // result = op.getbyte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/MiscellaneousOps/contract.py:119
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/MiscellaneousOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_itob(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:123
    // result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/MiscellaneousOps/contract.py:124
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/MiscellaneousOps/contract.py:126-127
    // @arc4.abimethod()
    // def verify_mulw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:128
    // result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/MiscellaneousOps/contract.py:129
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/MiscellaneousOps/contract.py:131-132
    // @arc4.abimethod()
    // def verify_replace(self, a: Bytes, b: UInt64, c: Bytes) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:133
    // result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/MiscellaneousOps/contract.py:134
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:136-137
    // @arc4.abimethod()
    // def verify_select_bytes(self, a: Bytes, b: Bytes, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:138
    // result = op.select_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:139
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:141-142
    // @arc4.abimethod()
    // def verify_select_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:143
    // result = op.select_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:144
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:146-147
    // @arc4.abimethod()
    // def verify_setbit_bytes(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:148
    // result = op.setbit_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:149
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_setbit_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:153
    // result = op.setbit_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:154
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_setbyte(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:158
    // result = op.setbyte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/MiscellaneousOps/contract.py:159
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/MiscellaneousOps/contract.py:161-162
    // @arc4.abimethod()
    // def verify_shl(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:163
    // result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/MiscellaneousOps/contract.py:164
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/MiscellaneousOps/contract.py:166-167
    // @arc4.abimethod()
    // def verify_shr(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:168
    // result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/MiscellaneousOps/contract.py:169
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:171-172
    // @arc4.abimethod()
    // def verify_sqrt(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:173
    // result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/MiscellaneousOps/contract.py:174
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/MiscellaneousOps/contract.py:176-177
    // @arc4.abimethod()
    // def verify_substring(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:178
    // result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/MiscellaneousOps/contract.py:179
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_string(a: bytes, b: bytes) -> bytes:
verify_json_ref_string:
    // tests/artifacts/MiscellaneousOps/contract.py:181-182
    // @arc4.abimethod()
    // def verify_json_ref_string(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:183
    // result = op.JsonRef.json_string(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONString
    // tests/artifacts/MiscellaneousOps/contract.py:184
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_uint64(a: bytes, b: bytes) -> uint64:
verify_json_ref_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:186-187
    // @arc4.abimethod()
    // def verify_json_ref_uint64(self, a: Bytes, b: Bytes) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:188
    // result = op.JsonRef.json_uint64(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONUint64
    // tests/artifacts/MiscellaneousOps/contract.py:189
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_object(a: bytes, b: bytes) -> bytes:
verify_json_ref_object:
    // tests/artifacts/MiscellaneousOps/contract.py:191-192
    // @arc4.abimethod()
    // def verify_json_ref_object(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:193
    // result = op.JsonRef.json_object(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONObject
    // tests/artifacts/MiscellaneousOps/contract.py:194
    // return result
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@42
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a 0x66dd7f96 0x4d9eceb2 0x19ba70ee // method "verify_addw(uint64,uint64)(uint64,uint64)", method "verify_base64_decode_standard(byte[])byte[]", method "verify_base64_decode_url(byte[])byte[]", method "verify_bytes_bitlen(byte[],uint64)uint64", method "verify_uint64_bitlen(uint64)uint64", method "verify_bsqrt(byte[])byte[]", method "verify_btoi(byte[])uint64", method "verify_bzero(uint64)byte[]", method "verify_concat(byte[],byte[],uint64,uint64)byte[]", method "verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)", method "verify_divw(uint64,uint64,uint64)uint64", method "verify_err()void", method "verify_exp(uint64,uint64)uint64", method "verify_expw(uint64,uint64)(uint64,uint64)", method "verify_extract(byte[],uint64,uint64)byte[]", method "verify_extract_from_2(byte[])byte[]", method "verify_extract_uint16(byte[],uint64)uint64", method "verify_extract_uint32(byte[],uint64)uint64", method "verify_extract_uint64(byte[],uint64)uint64", method "verify_getbit_bytes(byte[],uint64)uint64", method "verify_getbit_uint64(uint64,uint64)uint64", method "verify_getbyte(byte[],uint64)uint64", method "verify_itob(uint64)byte[]", method "verify_mulw(uint64,uint64)(uint64,uint64)", method "verify_replace(byte[],uint64,byte[])byte[]", method "verify_select_bytes(byte[],byte[],uint64)byte[]", method "verify_select_uint64(uint64,uint64,uint64)uint64", method "verify_setbit_bytes(byte[],uint64,uint64)byte[]", method "verify_setbit_uint64(uint64,uint64,uint64)uint64", method "verify_setbyte(byte[],uint64,uint64)byte[]", method "verify_shl(uint64,uint64)uint64", method "verify_shr(uint64,uint64)uint64", method "verify_sqrt(uint64)uint64", method "verify_substring(byte[],uint64,uint64)byte[]", method "verify_json_ref_string(byte[],byte[])byte[]", method "verify_json_ref_uint64(byte[],byte[])uint64", method "verify_json_ref_object(byte[],byte[])byte[]"
    txna ApplicationArgs 0
    match main_verify_addw_route@3 main_verify_base64_decode_standard_route@4 main_verify_base64_decode_url_route@5 main_verify_bytes_bitlen_route@6 main_verify_uint64_bitlen_route@7 main_verify_bsqrt_route@8 main_verify_btoi_route@9 main_verify_bzero_route@10 main_verify_concat_route@11 main_verify_divmodw_route@12 main_verify_divw_route@13 main_verify_err_route@14 main_verify_exp_route@15 main_verify_expw_route@16 main_verify_extract_route@17 main_verify_extract_from_2_route@18 main_verify_extract_uint16_route@19 main_verify_extract_uint32_route@20 main_verify_extract_uint64_route@21 main_verify_getbit_bytes_route@22 main_verify_getbit_uint64_route@23 main_verify_getbyte_route@24 main_verify_itob_route@25 main_verify_mulw_route@26 main_verify_replace_route@27 main_verify_select_bytes_route@28 main_verify_select_uint64_route@29 main_verify_setbit_bytes_route@30 main_verify_setbit_uint64_route@31 main_verify_setbyte_route@32 main_verify_shl_route@33 main_verify_shr_route@34 main_verify_sqrt_route@35 main_verify_substring_route@36 main_verify_json_ref_string_route@37 main_verify_json_ref_uint64_route@38 main_verify_json_ref_object_route@39

main_after_if_else@46:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    pushint 0 // 0
    return

main_verify_json_ref_object_route@39:
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    callsub verify_json_ref_object
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_uint64_route@38:
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    callsub verify_json_ref_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_string_route@37:
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    callsub verify_json_ref_string
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_substring_route@36:
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_sqrt_route@35:
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shr_route@34:
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shl_route@33:
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbyte_route@32:
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_uint64_route@31:
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_bytes_route@30:
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_uint64_route@29:
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_bytes_route@28:
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_replace_route@27:
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_mulw_route@26:
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_itob_route@25:
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbyte_route@24:
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_uint64_route@23:
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_bytes_route@22:
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint64_route@21:
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint32_route@20:
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint16_route@19:
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_from_2_route@18:
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_route@17:
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_expw_route@16:
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_exp_route@15:
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_err_route@14:
    // tests/artifacts/MiscellaneousOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:69
    // op.err()
    err

main_verify_divw_route@13:
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_divmodw_route@12:
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_divmodw
    uncover 3
    itob
    uncover 3
    itob
    concat
    uncover 2
    itob
    concat
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_concat_route@11:
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bzero_route@10:
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_btoi_route@9:
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bsqrt_route@8:
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_bitlen_route@7:
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_bitlen_route@6:
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_url_route@5:
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_standard_route@4:
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    callsub verify_base64_decode_standard
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_addw_route@3:
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@42:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@46
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/MiscellaneousOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_addw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:7
    // result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/MiscellaneousOps/contract.py:8
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/MiscellaneousOps/contract.py:10-11
    // @arc4.abimethod()
    // def verify_base64_decode_standard(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:12
    // result = op.base64_decode(op.Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:13
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/MiscellaneousOps/contract.py:15-16
    // @arc4.abimethod()
    // def verify_base64_decode_url(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:17
    // result = op.base64_decode(op.Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:18
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:20-21
    // @arc4.abimethod()
    // def verify_bytes_bitlen(self, a: Bytes, pad_a_size: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:22
    // a = op.bzero(pad_a_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/MiscellaneousOps/contract.py:23
    // result = op.bitlen(a)
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:24
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:26-27
    // @arc4.abimethod()
    // def verify_uint64_bitlen(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:28
    // result = op.bitlen(a)
    frame_dig -1
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:29
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_bsqrt(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:34
    // result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/MiscellaneousOps/contract.py:35
    // return result.bytes
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/MiscellaneousOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_btoi(self, a: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:39
    // result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:40
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/MiscellaneousOps/contract.py:42-43
    // @arc4.abimethod()
    // def verify_bzero(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:44
    // result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/MiscellaneousOps/contract.py:45
    // return op.sha256(result)
    sha256
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/MiscellaneousOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_concat(self, a: Bytes, b: Bytes, pad_a_size: UInt64, pad_b_size: UInt64) -> Bytes:
    proto 4 1
    // tests/artifacts/MiscellaneousOps/contract.py:49
    // a = op.bzero(pad_a_size) + a
    frame_dig -2
    bzero
    frame_dig -4
    concat
    frame_bury -4
    // tests/artifacts/MiscellaneousOps/contract.py:50
    // b = op.bzero(pad_b_size) + b
    frame_dig -1
    bzero
    frame_dig -3
    concat
    frame_bury -3
    // tests/artifacts/MiscellaneousOps/contract.py:51
    // result = a + b
    frame_dig -4
    frame_dig -3
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:52
    // result = op.sha256(result)
    sha256
    // tests/artifacts/MiscellaneousOps/contract.py:53
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/MiscellaneousOps/contract.py:55-58
    // @arc4.abimethod()
    // def verify_divmodw(
    //     self, a: UInt64, b: UInt64, c: UInt64, d: UInt64
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    // tests/artifacts/MiscellaneousOps/contract.py:59
    // result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/MiscellaneousOps/contract.py:60
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/MiscellaneousOps/contract.py:62-63
    // @arc4.abimethod()
    // def verify_divw(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:64
    // result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/MiscellaneousOps/contract.py:65
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/MiscellaneousOps/contract.py:71-72
    // @arc4.abimethod()
    // def verify_exp(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:73
    // result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/MiscellaneousOps/contract.py:74
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/MiscellaneousOps/contract.py:76-77
    // @arc4.abimethod()
    // def verify_expw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:78
    // result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/MiscellaneousOps/contract.py:79
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/MiscellaneousOps/contract.py:81-82
    // @arc4.abimethod()
    // def verify_extract(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:83
    // result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/MiscellaneousOps/contract.py:84
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/MiscellaneousOps/contract.py:86-87
    // @arc4.abimethod()
    // def verify_extract_from_2(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:88
    // result = op.extract(a, 2, 0)
    frame_dig -1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:89
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/MiscellaneousOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_extract_uint16(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:93
    // result = op.extract_uint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/MiscellaneousOps/contract.py:94
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/MiscellaneousOps/contract.py:96-97
    // @arc4.abimethod()
    // def verify_extract_uint32(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:98
    // result = op.extract_uint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/MiscellaneousOps/contract.py:99
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:101-102
    // @arc4.abimethod()
    // def verify_extract_uint64(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:103
    // result = op.extract_uint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/MiscellaneousOps/contract.py:104
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:106-107
    // @arc4.abimethod()
    // def verify_getbit_bytes(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:108
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:109
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:111-112
    // @arc4.abimethod()
    // def verify_getbit_uint64(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:113
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:114
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:116-117
    // @arc4.abimethod()
    // def verify_getbyte(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:118
    // result = op.getbyte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/MiscellaneousOps/contract.py:119
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/MiscellaneousOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_itob(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:123
    // result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/MiscellaneousOps/contract.py:124
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/MiscellaneousOps/contract.py:126-127
    // @arc4.abimethod()
    // def verify_mulw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:128
    // result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/MiscellaneousOps/contract.py:129
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/MiscellaneousOps/contract.py:131-132
    // @arc4.abimethod()
    // def verify_replace(self, a: Bytes, b: UInt64, c: Bytes) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:133
    // result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/MiscellaneousOps/contract.py:134
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:136-137
    // @arc4.abimethod()
    // def verify_select_bytes(self, a: Bytes, b: Bytes, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:138
    // result = op.select_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:139
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:141-142
    // @arc4.abimethod()
    // def verify_select_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:143
    // result = op.select_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:144
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:146-147
    // @arc4.abimethod()
    // def verify_setbit_bytes(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:148
    // result = op.setbit_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:149
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_setbit_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:153
    // result = op.setbit_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:154
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_setbyte(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:158
    // result = op.setbyte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/MiscellaneousOps/contract.py:159
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/MiscellaneousOps/contract.py:161-162
    // @arc4.abimethod()
    // def verify_shl(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:163
    // result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/MiscellaneousOps/contract.py:164
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/MiscellaneousOps/contract.py:166-167
    // @arc4.abimethod()
    // def verify_shr(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:168
    // result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/MiscellaneousOps/contract.py:169
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:171-172
    // @arc4.abimethod()
    // def verify_sqrt(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:173
    // result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/MiscellaneousOps/contract.py:174
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/MiscellaneousOps/contract.py:176-177
    // @arc4.abimethod()
    // def verify_substring(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:178
    // result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/MiscellaneousOps/contract.py:179
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_string(a: bytes, b: bytes) -> bytes:
verify_json_ref_string:
    // tests/artifacts/MiscellaneousOps/contract.py:181-182
    // @arc4.abimethod()
    // def verify_json_ref_string(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:183
    // result = op.JsonRef.json_string(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONString
    // tests/artifacts/MiscellaneousOps/contract.py:184
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_uint64(a: bytes, b: bytes) -> uint64:
verify_json_ref_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:186-187
    // @arc4.abimethod()
    // def verify_json_ref_uint64(self, a: Bytes, b: Bytes) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:188
    // result = op.JsonRef.json_uint64(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONUint64
    // tests/artifacts/MiscellaneousOps/contract.py:189
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_object(a: bytes, b: bytes) -> bytes:
verify_json_ref_object:
    // tests/artifacts/MiscellaneousOps/contract.py:191-192
    // @arc4.abimethod()
    // def verify_json_ref_object(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:193
    // result = op.JsonRef.json_object(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONObject
    // tests/artifacts/MiscellaneousOps/contract.py:194
    // return result
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc56.json b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc56.json
index eb85fa43..1f74dbc2 100644
--- a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc56.json
+++ b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc56.json
@@ -1001,21 +1001,21 @@
                         1051,
                         1059,
                         1088,
-                        1142,
-                        1186,
-                        1214,
-                        1237,
-                        1267,
-                        1288,
-                        1315,
-                        1345,
-                        1375
+                        1134,
+                        1178,
+                        1206,
+                        1229,
+                        1259,
+                        1280,
+                        1307,
+                        1337,
+                        1367
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        1409
+                        1401
                     ],
                     "errorMessage": "can only call when creating"
                 },
@@ -1049,15 +1049,15 @@
                         1054,
                         1062,
                         1091,
-                        1145,
-                        1189,
-                        1217,
-                        1240,
-                        1270,
-                        1291,
-                        1318,
-                        1348,
-                        1378
+                        1137,
+                        1181,
+                        1209,
+                        1232,
+                        1262,
+                        1283,
+                        1310,
+                        1340,
+                        1370
                     ],
                     "errorMessage": "can only call when not creating"
                 }
@@ -1070,19 +1070,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@42
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a 0x66dd7f96 0x4d9eceb2 0x19ba70ee // method "verify_addw(uint64,uint64)(uint64,uint64)", method "verify_base64_decode_standard(byte[])byte[]", method "verify_base64_decode_url(byte[])byte[]", method "verify_bytes_bitlen(byte[],uint64)uint64", method "verify_uint64_bitlen(uint64)uint64", method "verify_bsqrt(byte[])byte[]", method "verify_btoi(byte[])uint64", method "verify_bzero(uint64)byte[]", method "verify_concat(byte[],byte[],uint64,uint64)byte[]", method "verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)", method "verify_divw(uint64,uint64,uint64)uint64", method "verify_err()void", method "verify_exp(uint64,uint64)uint64", method "verify_expw(uint64,uint64)(uint64,uint64)", method "verify_extract(byte[],uint64,uint64)byte[]", method "verify_extract_from_2(byte[])byte[]", method "verify_extract_uint16(byte[],uint64)uint64", method "verify_extract_uint32(byte[],uint64)uint64", method "verify_extract_uint64(byte[],uint64)uint64", method "verify_getbit_bytes(byte[],uint64)uint64", method "verify_getbit_uint64(uint64,uint64)uint64", method "verify_getbyte(byte[],uint64)uint64", method "verify_itob(uint64)byte[]", method "verify_mulw(uint64,uint64)(uint64,uint64)", method "verify_replace(byte[],uint64,byte[])byte[]", method "verify_select_bytes(byte[],byte[],uint64)byte[]", method "verify_select_uint64(uint64,uint64,uint64)uint64", method "verify_setbit_bytes(byte[],uint64,uint64)byte[]", method "verify_setbit_uint64(uint64,uint64,uint64)uint64", method "verify_setbyte(byte[],uint64,uint64)byte[]", method "verify_shl(uint64,uint64)uint64", method "verify_shr(uint64,uint64)uint64", method "verify_sqrt(uint64)uint64", method "verify_substring(byte[],uint64,uint64)byte[]", method "verify_json_ref_string(byte[],byte[])byte[]", method "verify_json_ref_uint64(byte[],byte[])uint64", method "verify_json_ref_object(byte[],byte[])byte[]"
    txna ApplicationArgs 0
    match main_verify_addw_route@3 main_verify_base64_decode_standard_route@4 main_verify_base64_decode_url_route@5 main_verify_bytes_bitlen_route@6 main_verify_uint64_bitlen_route@7 main_verify_bsqrt_route@8 main_verify_btoi_route@9 main_verify_bzero_route@10 main_verify_concat_route@11 main_verify_divmodw_route@12 main_verify_divw_route@13 main_verify_err_route@14 main_verify_exp_route@15 main_verify_expw_route@16 main_verify_extract_route@17 main_verify_extract_from_2_route@18 main_verify_extract_uint16_route@19 main_verify_extract_uint32_route@20 main_verify_extract_uint64_route@21 main_verify_getbit_bytes_route@22 main_verify_getbit_uint64_route@23 main_verify_getbyte_route@24 main_verify_itob_route@25 main_verify_mulw_route@26 main_verify_replace_route@27 main_verify_select_bytes_route@28 main_verify_select_uint64_route@29 main_verify_setbit_bytes_route@30 main_verify_setbit_uint64_route@31 main_verify_setbyte_route@32 main_verify_shl_route@33 main_verify_shr_route@34 main_verify_sqrt_route@35 main_verify_substring_route@36 main_verify_json_ref_string_route@37 main_verify_json_ref_uint64_route@38 main_verify_json_ref_object_route@39

main_after_if_else@46:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    pushint 0 // 0
    return

main_verify_json_ref_object_route@39:
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    callsub verify_json_ref_object
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_uint64_route@38:
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    callsub verify_json_ref_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_string_route@37:
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    callsub verify_json_ref_string
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_substring_route@36:
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_sqrt_route@35:
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shr_route@34:
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shl_route@33:
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbyte_route@32:
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_uint64_route@31:
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_bytes_route@30:
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_uint64_route@29:
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_bytes_route@28:
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_replace_route@27:
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_mulw_route@26:
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_itob_route@25:
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbyte_route@24:
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_uint64_route@23:
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_bytes_route@22:
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint64_route@21:
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint32_route@20:
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint16_route@19:
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_from_2_route@18:
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_route@17:
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_expw_route@16:
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_exp_route@15:
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_err_route@14:
    // tests/artifacts/MiscellaneousOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:69
    // op.err()
    err

main_verify_divw_route@13:
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_divmodw_route@12:
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_divmodw
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    itob
    uncover 3
    uncover 3
    concat
    uncover 2
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_concat_route@11:
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bzero_route@10:
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_btoi_route@9:
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bsqrt_route@8:
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_bitlen_route@7:
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_bitlen_route@6:
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_url_route@5:
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_standard_route@4:
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    callsub verify_base64_decode_standard
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_addw_route@3:
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@42:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@46
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/MiscellaneousOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_addw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:7
    // result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/MiscellaneousOps/contract.py:8
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/MiscellaneousOps/contract.py:10-11
    // @arc4.abimethod()
    // def verify_base64_decode_standard(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:12
    // result = op.base64_decode(op.Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:13
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/MiscellaneousOps/contract.py:15-16
    // @arc4.abimethod()
    // def verify_base64_decode_url(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:17
    // result = op.base64_decode(op.Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:18
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:20-21
    // @arc4.abimethod()
    // def verify_bytes_bitlen(self, a: Bytes, pad_a_size: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:22
    // a = op.bzero(pad_a_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/MiscellaneousOps/contract.py:23
    // result = op.bitlen(a)
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:24
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:26-27
    // @arc4.abimethod()
    // def verify_uint64_bitlen(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:28
    // result = op.bitlen(a)
    frame_dig -1
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:29
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_bsqrt(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:34
    // result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/MiscellaneousOps/contract.py:35
    // return result.bytes
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/MiscellaneousOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_btoi(self, a: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:39
    // result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:40
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/MiscellaneousOps/contract.py:42-43
    // @arc4.abimethod()
    // def verify_bzero(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:44
    // result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/MiscellaneousOps/contract.py:45
    // return op.sha256(result)
    sha256
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/MiscellaneousOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_concat(self, a: Bytes, b: Bytes, pad_a_size: UInt64, pad_b_size: UInt64) -> Bytes:
    proto 4 1
    // tests/artifacts/MiscellaneousOps/contract.py:49
    // a = op.bzero(pad_a_size) + a
    frame_dig -2
    bzero
    frame_dig -4
    concat
    frame_bury -4
    // tests/artifacts/MiscellaneousOps/contract.py:50
    // b = op.bzero(pad_b_size) + b
    frame_dig -1
    bzero
    frame_dig -3
    concat
    frame_bury -3
    // tests/artifacts/MiscellaneousOps/contract.py:51
    // result = a + b
    frame_dig -4
    frame_dig -3
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:52
    // result = op.sha256(result)
    sha256
    // tests/artifacts/MiscellaneousOps/contract.py:53
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/MiscellaneousOps/contract.py:55-58
    // @arc4.abimethod()
    // def verify_divmodw(
    //     self, a: UInt64, b: UInt64, c: UInt64, d: UInt64
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    // tests/artifacts/MiscellaneousOps/contract.py:59
    // result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/MiscellaneousOps/contract.py:60
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/MiscellaneousOps/contract.py:62-63
    // @arc4.abimethod()
    // def verify_divw(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:64
    // result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/MiscellaneousOps/contract.py:65
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/MiscellaneousOps/contract.py:71-72
    // @arc4.abimethod()
    // def verify_exp(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:73
    // result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/MiscellaneousOps/contract.py:74
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/MiscellaneousOps/contract.py:76-77
    // @arc4.abimethod()
    // def verify_expw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:78
    // result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/MiscellaneousOps/contract.py:79
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/MiscellaneousOps/contract.py:81-82
    // @arc4.abimethod()
    // def verify_extract(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:83
    // result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/MiscellaneousOps/contract.py:84
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/MiscellaneousOps/contract.py:86-87
    // @arc4.abimethod()
    // def verify_extract_from_2(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:88
    // result = op.extract(a, 2, 0)
    frame_dig -1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:89
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/MiscellaneousOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_extract_uint16(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:93
    // result = op.extract_uint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/MiscellaneousOps/contract.py:94
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/MiscellaneousOps/contract.py:96-97
    // @arc4.abimethod()
    // def verify_extract_uint32(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:98
    // result = op.extract_uint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/MiscellaneousOps/contract.py:99
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:101-102
    // @arc4.abimethod()
    // def verify_extract_uint64(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:103
    // result = op.extract_uint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/MiscellaneousOps/contract.py:104
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:106-107
    // @arc4.abimethod()
    // def verify_getbit_bytes(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:108
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:109
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:111-112
    // @arc4.abimethod()
    // def verify_getbit_uint64(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:113
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:114
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:116-117
    // @arc4.abimethod()
    // def verify_getbyte(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:118
    // result = op.getbyte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/MiscellaneousOps/contract.py:119
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/MiscellaneousOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_itob(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:123
    // result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/MiscellaneousOps/contract.py:124
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/MiscellaneousOps/contract.py:126-127
    // @arc4.abimethod()
    // def verify_mulw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:128
    // result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/MiscellaneousOps/contract.py:129
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/MiscellaneousOps/contract.py:131-132
    // @arc4.abimethod()
    // def verify_replace(self, a: Bytes, b: UInt64, c: Bytes) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:133
    // result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/MiscellaneousOps/contract.py:134
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:136-137
    // @arc4.abimethod()
    // def verify_select_bytes(self, a: Bytes, b: Bytes, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:138
    // result = op.select_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:139
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:141-142
    // @arc4.abimethod()
    // def verify_select_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:143
    // result = op.select_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:144
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:146-147
    // @arc4.abimethod()
    // def verify_setbit_bytes(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:148
    // result = op.setbit_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:149
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_setbit_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:153
    // result = op.setbit_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:154
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_setbyte(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:158
    // result = op.setbyte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/MiscellaneousOps/contract.py:159
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/MiscellaneousOps/contract.py:161-162
    // @arc4.abimethod()
    // def verify_shl(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:163
    // result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/MiscellaneousOps/contract.py:164
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/MiscellaneousOps/contract.py:166-167
    // @arc4.abimethod()
    // def verify_shr(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:168
    // result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/MiscellaneousOps/contract.py:169
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:171-172
    // @arc4.abimethod()
    // def verify_sqrt(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:173
    // result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/MiscellaneousOps/contract.py:174
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/MiscellaneousOps/contract.py:176-177
    // @arc4.abimethod()
    // def verify_substring(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:178
    // result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/MiscellaneousOps/contract.py:179
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_string(a: bytes, b: bytes) -> bytes:
verify_json_ref_string:
    // tests/artifacts/MiscellaneousOps/contract.py:181-182
    // @arc4.abimethod()
    // def verify_json_ref_string(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:183
    // result = op.JsonRef.json_string(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONString
    // tests/artifacts/MiscellaneousOps/contract.py:184
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_uint64(a: bytes, b: bytes) -> uint64:
verify_json_ref_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:186-187
    // @arc4.abimethod()
    // def verify_json_ref_uint64(self, a: Bytes, b: Bytes) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:188
    // result = op.JsonRef.json_uint64(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONUint64
    // tests/artifacts/MiscellaneousOps/contract.py:189
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_object(a: bytes, b: bytes) -> bytes:
verify_json_ref_object:
    // tests/artifacts/MiscellaneousOps/contract.py:191-192
    // @arc4.abimethod()
    // def verify_json_ref_object(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:193
    // result = op.JsonRef.json_object(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONObject
    // tests/artifacts/MiscellaneousOps/contract.py:194
    // return result
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@42
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a 0x66dd7f96 0x4d9eceb2 0x19ba70ee // method "verify_addw(uint64,uint64)(uint64,uint64)", method "verify_base64_decode_standard(byte[])byte[]", method "verify_base64_decode_url(byte[])byte[]", method "verify_bytes_bitlen(byte[],uint64)uint64", method "verify_uint64_bitlen(uint64)uint64", method "verify_bsqrt(byte[])byte[]", method "verify_btoi(byte[])uint64", method "verify_bzero(uint64)byte[]", method "verify_concat(byte[],byte[],uint64,uint64)byte[]", method "verify_divmodw(uint64,uint64,uint64,uint64)(uint64,uint64,uint64,uint64)", method "verify_divw(uint64,uint64,uint64)uint64", method "verify_err()void", method "verify_exp(uint64,uint64)uint64", method "verify_expw(uint64,uint64)(uint64,uint64)", method "verify_extract(byte[],uint64,uint64)byte[]", method "verify_extract_from_2(byte[])byte[]", method "verify_extract_uint16(byte[],uint64)uint64", method "verify_extract_uint32(byte[],uint64)uint64", method "verify_extract_uint64(byte[],uint64)uint64", method "verify_getbit_bytes(byte[],uint64)uint64", method "verify_getbit_uint64(uint64,uint64)uint64", method "verify_getbyte(byte[],uint64)uint64", method "verify_itob(uint64)byte[]", method "verify_mulw(uint64,uint64)(uint64,uint64)", method "verify_replace(byte[],uint64,byte[])byte[]", method "verify_select_bytes(byte[],byte[],uint64)byte[]", method "verify_select_uint64(uint64,uint64,uint64)uint64", method "verify_setbit_bytes(byte[],uint64,uint64)byte[]", method "verify_setbit_uint64(uint64,uint64,uint64)uint64", method "verify_setbyte(byte[],uint64,uint64)byte[]", method "verify_shl(uint64,uint64)uint64", method "verify_shr(uint64,uint64)uint64", method "verify_sqrt(uint64)uint64", method "verify_substring(byte[],uint64,uint64)byte[]", method "verify_json_ref_string(byte[],byte[])byte[]", method "verify_json_ref_uint64(byte[],byte[])uint64", method "verify_json_ref_object(byte[],byte[])byte[]"
    txna ApplicationArgs 0
    match main_verify_addw_route@3 main_verify_base64_decode_standard_route@4 main_verify_base64_decode_url_route@5 main_verify_bytes_bitlen_route@6 main_verify_uint64_bitlen_route@7 main_verify_bsqrt_route@8 main_verify_btoi_route@9 main_verify_bzero_route@10 main_verify_concat_route@11 main_verify_divmodw_route@12 main_verify_divw_route@13 main_verify_err_route@14 main_verify_exp_route@15 main_verify_expw_route@16 main_verify_extract_route@17 main_verify_extract_from_2_route@18 main_verify_extract_uint16_route@19 main_verify_extract_uint32_route@20 main_verify_extract_uint64_route@21 main_verify_getbit_bytes_route@22 main_verify_getbit_uint64_route@23 main_verify_getbyte_route@24 main_verify_itob_route@25 main_verify_mulw_route@26 main_verify_replace_route@27 main_verify_select_bytes_route@28 main_verify_select_uint64_route@29 main_verify_setbit_bytes_route@30 main_verify_setbit_uint64_route@31 main_verify_setbyte_route@32 main_verify_shl_route@33 main_verify_shr_route@34 main_verify_sqrt_route@35 main_verify_substring_route@36 main_verify_json_ref_string_route@37 main_verify_json_ref_uint64_route@38 main_verify_json_ref_object_route@39

main_after_if_else@46:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    pushint 0 // 0
    return

main_verify_json_ref_object_route@39:
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    callsub verify_json_ref_object
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_uint64_route@38:
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    callsub verify_json_ref_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_json_ref_string_route@37:
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    callsub verify_json_ref_string
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_substring_route@36:
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_sqrt_route@35:
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shr_route@34:
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_shl_route@33:
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbyte_route@32:
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_uint64_route@31:
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_setbit_bytes_route@30:
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_uint64_route@29:
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_select_bytes_route@28:
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_replace_route@27:
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_mulw_route@26:
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_itob_route@25:
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbyte_route@24:
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_uint64_route@23:
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_getbit_bytes_route@22:
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint64_route@21:
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint32_route@20:
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_uint16_route@19:
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_from_2_route@18:
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_extract_route@17:
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_expw_route@16:
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_exp_route@15:
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_err_route@14:
    // tests/artifacts/MiscellaneousOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:69
    // op.err()
    err

main_verify_divw_route@13:
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_divmodw_route@12:
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    callsub verify_divmodw
    uncover 3
    itob
    uncover 3
    itob
    concat
    uncover 2
    itob
    concat
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_concat_route@11:
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bzero_route@10:
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_btoi_route@9:
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bsqrt_route@8:
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_bitlen_route@7:
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_bitlen_route@6:
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_url_route@5:
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_base64_decode_standard_route@4:
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    callsub verify_base64_decode_standard
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_addw_route@3:
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@42:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@46
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/MiscellaneousOps/contract.py:5-6
    // @arc4.abimethod()
    // def verify_addw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:7
    // result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/MiscellaneousOps/contract.py:8
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/MiscellaneousOps/contract.py:10-11
    // @arc4.abimethod()
    // def verify_base64_decode_standard(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:12
    // result = op.base64_decode(op.Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:13
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/MiscellaneousOps/contract.py:15-16
    // @arc4.abimethod()
    // def verify_base64_decode_url(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:17
    // result = op.base64_decode(op.Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/MiscellaneousOps/contract.py:18
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:20-21
    // @arc4.abimethod()
    // def verify_bytes_bitlen(self, a: Bytes, pad_a_size: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:22
    // a = op.bzero(pad_a_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/MiscellaneousOps/contract.py:23
    // result = op.bitlen(a)
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:24
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/MiscellaneousOps/contract.py:26-27
    // @arc4.abimethod()
    // def verify_uint64_bitlen(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:28
    // result = op.bitlen(a)
    frame_dig -1
    bitlen
    // tests/artifacts/MiscellaneousOps/contract.py:29
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:31-32
    // @arc4.abimethod()
    // def verify_bsqrt(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:34
    // result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/MiscellaneousOps/contract.py:35
    // return result.bytes
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/MiscellaneousOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_btoi(self, a: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:39
    // result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/MiscellaneousOps/contract.py:40
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/MiscellaneousOps/contract.py:42-43
    // @arc4.abimethod()
    // def verify_bzero(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:44
    // result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/MiscellaneousOps/contract.py:45
    // return op.sha256(result)
    sha256
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/MiscellaneousOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_concat(self, a: Bytes, b: Bytes, pad_a_size: UInt64, pad_b_size: UInt64) -> Bytes:
    proto 4 1
    // tests/artifacts/MiscellaneousOps/contract.py:49
    // a = op.bzero(pad_a_size) + a
    frame_dig -2
    bzero
    frame_dig -4
    concat
    frame_bury -4
    // tests/artifacts/MiscellaneousOps/contract.py:50
    // b = op.bzero(pad_b_size) + b
    frame_dig -1
    bzero
    frame_dig -3
    concat
    frame_bury -3
    // tests/artifacts/MiscellaneousOps/contract.py:51
    // result = a + b
    frame_dig -4
    frame_dig -3
    concat
    // tests/artifacts/MiscellaneousOps/contract.py:52
    // result = op.sha256(result)
    sha256
    // tests/artifacts/MiscellaneousOps/contract.py:53
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/MiscellaneousOps/contract.py:55-58
    // @arc4.abimethod()
    // def verify_divmodw(
    //     self, a: UInt64, b: UInt64, c: UInt64, d: UInt64
    // ) -> tuple[UInt64, UInt64, UInt64, UInt64]:
    proto 4 4
    // tests/artifacts/MiscellaneousOps/contract.py:59
    // result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/MiscellaneousOps/contract.py:60
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/MiscellaneousOps/contract.py:62-63
    // @arc4.abimethod()
    // def verify_divw(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:64
    // result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/MiscellaneousOps/contract.py:65
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/MiscellaneousOps/contract.py:71-72
    // @arc4.abimethod()
    // def verify_exp(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:73
    // result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/MiscellaneousOps/contract.py:74
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/MiscellaneousOps/contract.py:76-77
    // @arc4.abimethod()
    // def verify_expw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:78
    // result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/MiscellaneousOps/contract.py:79
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/MiscellaneousOps/contract.py:81-82
    // @arc4.abimethod()
    // def verify_extract(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:83
    // result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/MiscellaneousOps/contract.py:84
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/MiscellaneousOps/contract.py:86-87
    // @arc4.abimethod()
    // def verify_extract_from_2(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:88
    // result = op.extract(a, 2, 0)
    frame_dig -1
    extract 2 0
    // tests/artifacts/MiscellaneousOps/contract.py:89
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/MiscellaneousOps/contract.py:91-92
    // @arc4.abimethod()
    // def verify_extract_uint16(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:93
    // result = op.extract_uint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/MiscellaneousOps/contract.py:94
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/MiscellaneousOps/contract.py:96-97
    // @arc4.abimethod()
    // def verify_extract_uint32(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:98
    // result = op.extract_uint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/MiscellaneousOps/contract.py:99
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:101-102
    // @arc4.abimethod()
    // def verify_extract_uint64(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:103
    // result = op.extract_uint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/MiscellaneousOps/contract.py:104
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:106-107
    // @arc4.abimethod()
    // def verify_getbit_bytes(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:108
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:109
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:111-112
    // @arc4.abimethod()
    // def verify_getbit_uint64(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:113
    // result = op.getbit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/MiscellaneousOps/contract.py:114
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:116-117
    // @arc4.abimethod()
    // def verify_getbyte(self, a: Bytes, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:118
    // result = op.getbyte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/MiscellaneousOps/contract.py:119
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/MiscellaneousOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_itob(self, a: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:123
    // result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/MiscellaneousOps/contract.py:124
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/MiscellaneousOps/contract.py:126-127
    // @arc4.abimethod()
    // def verify_mulw(self, a: UInt64, b: UInt64) -> tuple[UInt64, UInt64]:
    proto 2 2
    // tests/artifacts/MiscellaneousOps/contract.py:128
    // result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/MiscellaneousOps/contract.py:129
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/MiscellaneousOps/contract.py:131-132
    // @arc4.abimethod()
    // def verify_replace(self, a: Bytes, b: UInt64, c: Bytes) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:133
    // result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/MiscellaneousOps/contract.py:134
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:136-137
    // @arc4.abimethod()
    // def verify_select_bytes(self, a: Bytes, b: Bytes, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:138
    // result = op.select_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:139
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:141-142
    // @arc4.abimethod()
    // def verify_select_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:143
    // result = op.select_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/MiscellaneousOps/contract.py:144
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/MiscellaneousOps/contract.py:146-147
    // @arc4.abimethod()
    // def verify_setbit_bytes(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:148
    // result = op.setbit_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:149
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_setbit_uint64(self, a: UInt64, b: UInt64, c: UInt64) -> UInt64:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:153
    // result = op.setbit_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/MiscellaneousOps/contract.py:154
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/MiscellaneousOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_setbyte(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:158
    // result = op.setbyte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/MiscellaneousOps/contract.py:159
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/MiscellaneousOps/contract.py:161-162
    // @arc4.abimethod()
    // def verify_shl(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:163
    // result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/MiscellaneousOps/contract.py:164
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/MiscellaneousOps/contract.py:166-167
    // @arc4.abimethod()
    // def verify_shr(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:168
    // result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/MiscellaneousOps/contract.py:169
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/MiscellaneousOps/contract.py:171-172
    // @arc4.abimethod()
    // def verify_sqrt(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/MiscellaneousOps/contract.py:173
    // result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/MiscellaneousOps/contract.py:174
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/MiscellaneousOps/contract.py:176-177
    // @arc4.abimethod()
    // def verify_substring(self, a: Bytes, b: UInt64, c: UInt64) -> Bytes:
    proto 3 1
    // tests/artifacts/MiscellaneousOps/contract.py:178
    // result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/MiscellaneousOps/contract.py:179
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_string(a: bytes, b: bytes) -> bytes:
verify_json_ref_string:
    // tests/artifacts/MiscellaneousOps/contract.py:181-182
    // @arc4.abimethod()
    // def verify_json_ref_string(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:183
    // result = op.JsonRef.json_string(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONString
    // tests/artifacts/MiscellaneousOps/contract.py:184
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_uint64(a: bytes, b: bytes) -> uint64:
verify_json_ref_uint64:
    // tests/artifacts/MiscellaneousOps/contract.py:186-187
    // @arc4.abimethod()
    // def verify_json_ref_uint64(self, a: Bytes, b: Bytes) -> UInt64:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:188
    // result = op.JsonRef.json_uint64(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONUint64
    // tests/artifacts/MiscellaneousOps/contract.py:189
    // return result
    retsub


// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_json_ref_object(a: bytes, b: bytes) -> bytes:
verify_json_ref_object:
    // tests/artifacts/MiscellaneousOps/contract.py:191-192
    // @arc4.abimethod()
    // def verify_json_ref_object(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/MiscellaneousOps/contract.py:193
    // result = op.JsonRef.json_object(a, b)
    frame_dig -2
    frame_dig -1
    json_ref JSONObject
    // tests/artifacts/MiscellaneousOps/contract.py:194
    // return result
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "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",
+        "approval": "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",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc56.json b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc56.json
index 3a4d3e63..2876a703 100644
--- a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc56.json
+++ b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc56.json
@@ -1731,8 +1731,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateMutations/data/StateMutations.approval.teal b/tests/artifacts/StateMutations/data/StateMutations.approval.teal
index 97187f1b..8d261483 100644
--- a/tests/artifacts/StateMutations/data/StateMutations.approval.teal
+++ b/tests/artifacts/StateMutations/data/StateMutations.approval.teal
@@ -284,7 +284,11 @@ opt_in:
     // tests/artifacts/StateMutations/statemutations.py:34
     // self.glob.value = MyArray()
     bytec 4 // "glob"
+    // tests/artifacts/StateMutations/statemutations.py:33
+    // self.glob_assign.value = MyArray()
     bytec_2 // 0x0000
+    // tests/artifacts/StateMutations/statemutations.py:34
+    // self.glob.value = MyArray()
     app_global_put
     // tests/artifacts/StateMutations/statemutations.py:35
     // self.box.value = MyArray()
@@ -292,13 +296,21 @@ opt_in:
     box_del
     pop
     bytec_0 // "box"
+    // tests/artifacts/StateMutations/statemutations.py:33
+    // self.glob_assign.value = MyArray()
     bytec_2 // 0x0000
+    // tests/artifacts/StateMutations/statemutations.py:35
+    // self.box.value = MyArray()
     box_put
     // tests/artifacts/StateMutations/statemutations.py:36
     // self.loc[Txn.sender] = MyArray()
     txn Sender
     bytec 5 // "loc"
+    // tests/artifacts/StateMutations/statemutations.py:33
+    // self.glob_assign.value = MyArray()
     bytec_2 // 0x0000
+    // tests/artifacts/StateMutations/statemutations.py:36
+    // self.loc[Txn.sender] = MyArray()
     app_local_put
     // tests/artifacts/StateMutations/statemutations.py:37
     // self.map[Txn.sender] = MyArray()
@@ -308,7 +320,11 @@ opt_in:
     dup
     box_del
     pop
+    // tests/artifacts/StateMutations/statemutations.py:33
+    // self.glob_assign.value = MyArray()
     bytec_2 // 0x0000
+    // tests/artifacts/StateMutations/statemutations.py:37
+    // self.map[Txn.sender] = MyArray()
     box_put
     retsub
 
@@ -348,7 +364,11 @@ append:
     swap
     extract 2 0
     intc_1 // 1
+    // tests/artifacts/StateMutations/statemutations.py:43
+    // arr.append(struct.copy())
     bytec 6 // 0x00020000000000000001000a000362617a
+    // tests/artifacts/StateMutations/statemutations.py:46
+    // self.no_proxy.append(struct.copy())
     callsub dynamic_array_concat_dynamic_element
     bytec_1 // "no_proxy"
     swap
@@ -365,7 +385,11 @@ append:
     swap
     extract 2 0
     intc_1 // 1
+    // tests/artifacts/StateMutations/statemutations.py:43
+    // arr.append(struct.copy())
     bytec 6 // 0x00020000000000000001000a000362617a
+    // tests/artifacts/StateMutations/statemutations.py:47
+    // self.glob.value.append(struct.copy())
     callsub dynamic_array_concat_dynamic_element
     bytec 4 // "glob"
     swap
@@ -384,7 +408,11 @@ append:
     swap
     extract 2 0
     intc_1 // 1
+    // tests/artifacts/StateMutations/statemutations.py:43
+    // arr.append(struct.copy())
     bytec 6 // 0x00020000000000000001000a000362617a
+    // tests/artifacts/StateMutations/statemutations.py:48
+    // self.loc[Txn.sender].append(struct.copy())
     callsub dynamic_array_concat_dynamic_element
     bytec 5 // "loc"
     swap
@@ -400,7 +428,11 @@ append:
     swap
     extract 2 0
     intc_1 // 1
+    // tests/artifacts/StateMutations/statemutations.py:43
+    // arr.append(struct.copy())
     bytec 6 // 0x00020000000000000001000a000362617a
+    // tests/artifacts/StateMutations/statemutations.py:49
+    // self.box.value.append(struct.copy())
     callsub dynamic_array_concat_dynamic_element
     bytec_0 // "box"
     box_del
@@ -422,7 +454,11 @@ append:
     swap
     extract 2 0
     intc_1 // 1
+    // tests/artifacts/StateMutations/statemutations.py:43
+    // arr.append(struct.copy())
     bytec 6 // 0x00020000000000000001000a000362617a
+    // tests/artifacts/StateMutations/statemutations.py:50
+    // self.map[Txn.sender].append(struct.copy())
     callsub dynamic_array_concat_dynamic_element
     dig 1
     box_del
@@ -443,21 +479,24 @@ modify:
     // arr[0].baz = modified
     dup
     extract 2 0
-    dup
+    dig 1
     intc_0 // 0
     extract_uint16
-    dig 2
+    dig 1
     intc_0 // 0
     extract_uint16
+    dig 1
     intc_1 // 1
-    - // on error: Index access is out of bounds
-    dig 2
-    len
+    - // on error: index access is out of bounds
     dig 3
+    len
+    dig 4
     intc_2 // 2
     extract_uint16
     uncover 2
     select
+    uncover 3
+    cover 2
     substring3
     dup
     intc_3 // 8
@@ -471,6 +510,8 @@ modify:
     // tests/artifacts/StateMutations/statemutations.py:57
     // arr[0].baz = modified
     concat
+    swap
+    assert // index access is out of bounds
     intc_0 // 0
     callsub dynamic_array_replace_dynamic_element
     // tests/artifacts/StateMutations/statemutations.py:58
@@ -486,21 +527,24 @@ modify:
     assert // check self.no_proxy exists
     dup
     extract 2 0
-    dup
+    dig 1
     intc_0 // 0
     extract_uint16
-    dig 2
+    dig 1
     intc_0 // 0
     extract_uint16
+    dig 1
     intc_1 // 1
-    - // on error: Index access is out of bounds
-    dig 2
-    len
+    - // on error: index access is out of bounds
     dig 3
+    len
+    dig 4
     intc_2 // 2
     extract_uint16
     uncover 2
     select
+    uncover 3
+    cover 2
     substring3
     dup
     intc_3 // 8
@@ -514,6 +558,8 @@ modify:
     // tests/artifacts/StateMutations/statemutations.py:60
     // self.no_proxy[0].baz = modified
     concat
+    swap
+    assert // index access is out of bounds
     intc_0 // 0
     callsub dynamic_array_replace_dynamic_element
     bytec_1 // "no_proxy"
@@ -527,21 +573,24 @@ modify:
     assert // check self.glob exists
     dup
     extract 2 0
-    dup
+    dig 1
     intc_0 // 0
     extract_uint16
-    dig 2
+    dig 1
     intc_0 // 0
     extract_uint16
+    dig 1
     intc_1 // 1
-    - // on error: Index access is out of bounds
-    dig 2
-    len
+    - // on error: index access is out of bounds
     dig 3
+    len
+    dig 4
     intc_2 // 2
     extract_uint16
     uncover 2
     select
+    uncover 3
+    cover 2
     substring3
     dup
     intc_3 // 8
@@ -555,6 +604,8 @@ modify:
     // tests/artifacts/StateMutations/statemutations.py:61
     // self.glob.value[0].baz = modified
     concat
+    swap
+    assert // index access is out of bounds
     intc_0 // 0
     callsub dynamic_array_replace_dynamic_element
     bytec 4 // "glob"
@@ -570,21 +621,24 @@ modify:
     assert // check self.loc exists for account
     dup
     extract 2 0
-    dup
+    dig 1
     intc_0 // 0
     extract_uint16
-    dig 2
+    dig 1
     intc_0 // 0
     extract_uint16
+    dig 1
     intc_1 // 1
-    - // on error: Index access is out of bounds
-    dig 2
-    len
+    - // on error: index access is out of bounds
     dig 3
+    len
+    dig 4
     intc_2 // 2
     extract_uint16
     uncover 2
     select
+    uncover 3
+    cover 2
     substring3
     dup
     intc_3 // 8
@@ -598,6 +652,8 @@ modify:
     // tests/artifacts/StateMutations/statemutations.py:62
     // self.loc[Txn.sender][0].baz = modified
     concat
+    swap
+    assert // index access is out of bounds
     intc_0 // 0
     callsub dynamic_array_replace_dynamic_element
     bytec 5 // "loc"
@@ -610,21 +666,24 @@ modify:
     assert // check self.box exists
     dup
     extract 2 0
-    dup
+    dig 1
     intc_0 // 0
     extract_uint16
-    dig 2
+    dig 1
     intc_0 // 0
     extract_uint16
+    dig 1
     intc_1 // 1
-    - // on error: Index access is out of bounds
-    dig 2
-    len
+    - // on error: index access is out of bounds
     dig 3
+    len
+    dig 4
     intc_2 // 2
     extract_uint16
     uncover 2
     select
+    uncover 3
+    cover 2
     substring3
     dup
     intc_3 // 8
@@ -638,6 +697,8 @@ modify:
     // tests/artifacts/StateMutations/statemutations.py:63
     // self.box.value[0].baz = modified
     concat
+    swap
+    assert // index access is out of bounds
     intc_0 // 0
     callsub dynamic_array_replace_dynamic_element
     bytec_0 // "box"
@@ -656,21 +717,24 @@ modify:
     assert // check self.map entry exists
     dup
     extract 2 0
-    dup
+    dig 1
     intc_0 // 0
     extract_uint16
-    dig 2
+    dig 1
     intc_0 // 0
     extract_uint16
+    dig 1
     intc_1 // 1
-    - // on error: Index access is out of bounds
-    dig 2
-    len
+    - // on error: index access is out of bounds
     dig 3
+    len
+    dig 4
     intc_2 // 2
     extract_uint16
     uncover 2
     select
+    uncover 3
+    cover 2
     substring3
     dup
     intc_3 // 8
@@ -684,6 +748,8 @@ modify:
     // tests/artifacts/StateMutations/statemutations.py:64
     // self.map[Txn.sender][0].baz = modified
     concat
+    swap
+    assert // index access is out of bounds
     intc_0 // 0
     callsub dynamic_array_replace_dynamic_element
     dig 1
diff --git a/tests/artifacts/StateMutations/data/StateMutations.arc32.json b/tests/artifacts/StateMutations/data/StateMutations.arc32.json
index 05f7b776..b82bdb32 100644
--- a/tests/artifacts/StateMutations/data/StateMutations.arc32.json
+++ b/tests/artifacts/StateMutations/data/StateMutations.arc32.json
@@ -17,7 +17,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateMutations.statemutations.StateMutations.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock "box" "no_proxy" 0x0000 "glob_assign" "glob" "loc" 0x00020000000000000001000a000362617a 0x00086d6f646966696564 "map"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateMutations/statemutations.py:24
    // self.no_proxy = MyArray()
    bytec_1 // "no_proxy"
    bytec_2 // 0x0000
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@8
    pushbytess 0x526e8bbf 0x95fef13d 0x0c29444b // method "append()void", method "modify()void", method "get()(uint64,string)[]"
    txna ApplicationArgs 0
    match main_append_route@5 main_modify_route@6 main_get_route@7

main_after_if_else@11:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    intc_0 // 0
    return

main_get_route@7:
    // tests/artifacts/StateMutations/statemutations.py:66
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_modify_route@6:
    // tests/artifacts/StateMutations/statemutations.py:52
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub modify
    intc_1 // 1
    return

main_append_route@5:
    // tests/artifacts/StateMutations/statemutations.py:39
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub append
    intc_1 // 1
    return

main_bare_routing@8:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn OnCompletion
    switch main___algopy_default_create@10 main_opt_in@9
    b main_after_if_else@11

main_opt_in@9:
    // tests/artifacts/StateMutations/statemutations.py:31
    // @arc4.baremethod(allow_actions=["OptIn"])
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main___algopy_default_create@10:
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    pushbytes ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_replace_dynamic_element(source: bytes, new_item: bytes, index: uint64) -> bytes:
dynamic_array_replace_dynamic_element:
    proto 3 1
    frame_dig -3
    substring 0 2
    dup
    btoi
    frame_dig -3
    extract 2 0
    frame_dig -1
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    frame_dig -1
    intc_1 // 1
    +
    intc_2 // 2
    *
    dup
    cover 4
    dig 2
    swap
    extract_uint16
    dig 2
    len
    dig 4
    frame_dig -1
    -
    intc_1 // 1
    -
    dig 1
    uncover 3
    uncover 2
    select
    dup
    dig 3
    -
    cover 5
    frame_dig -2
    len
    cover 5
    dig 3
    intc_0 // 0
    uncover 4
    substring3
    frame_dig -2
    concat
    uncover 3
    uncover 2
    uncover 3
    substring3
    concat
    swap
    intc_2 // 2
    *

dynamic_array_replace_dynamic_element_for_header@2:
    frame_dig 1
    frame_dig 5
    <
    bz dynamic_array_replace_dynamic_element_after_for@5
    frame_dig 4
    dup
    frame_dig 1
    dup
    cover 3
    extract_uint16
    frame_dig 3
    +
    frame_dig 2
    -
    itob
    extract 6 2
    dig 2
    swap
    replace3
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 1
    b dynamic_array_replace_dynamic_element_for_header@2

dynamic_array_replace_dynamic_element_after_for@5:
    frame_dig 0
    frame_dig 4
    concat
    frame_bury 0
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.opt_in() -> void:
opt_in:
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_3 // "glob_assign"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    bytec 4 // "glob"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    bytec_2 // 0x0000
    box_put
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    txn Sender
    bytec 5 // "loc"
    bytec_2 // 0x0000
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_del
    pop
    bytec_2 // 0x0000
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.append() -> void:
append:
    // tests/artifacts/StateMutations/statemutations.py:42
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:45
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.modify() -> void:
modify:
    // tests/artifacts/StateMutations/statemutations.py:56
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:58
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.get() -> bytes:
get:
    // tests/artifacts/StateMutations/statemutations.py:68
    // a0 = self.no_proxy.copy()
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    // tests/artifacts/StateMutations/statemutations.py:69
    // a1 = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:70
    // a2 = self.glob.value.copy()
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    // tests/artifacts/StateMutations/statemutations.py:71
    // a3 = self.loc[Txn.sender].copy()
    txn Sender
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    // tests/artifacts/StateMutations/statemutations.py:72
    // a4 = self.box.value.copy()
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    // tests/artifacts/StateMutations/statemutations.py:73
    // a5 = self.map[Txn.sender].copy()
    bytec 8 // "map"
    txn Sender
    concat
    box_get
    assert // check self.map entry exists
    // tests/artifacts/StateMutations/statemutations.py:75
    // assert a0 == a1, "expected global assign == no_proxy"
    dig 5
    uncover 5
    ==
    assert // expected global assign == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:76
    // assert a0 == a2, "expected global == no_proxy"
    dig 4
    uncover 4
    ==
    assert // expected global == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:77
    // assert a0 == a3, "expected local == no_proxy"
    dig 3
    uncover 3
    ==
    assert // expected local == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:78
    // assert a0 == a4, "expected box == no_proxy"
    dig 2
    uncover 2
    ==
    assert // expected box == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:79
    // assert a0 == a5, "expected map == no_proxy"
    dig 1
    ==
    assert // expected map == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:80
    // return a0
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateMutations.statemutations.StateMutations.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock "box" "no_proxy" 0x0000 "glob_assign" "glob" "loc" 0x00020000000000000001000a000362617a 0x00086d6f646966696564 "map"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateMutations/statemutations.py:24
    // self.no_proxy = MyArray()
    bytec_1 // "no_proxy"
    bytec_2 // 0x0000
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@8
    pushbytess 0x526e8bbf 0x95fef13d 0x0c29444b // method "append()void", method "modify()void", method "get()(uint64,string)[]"
    txna ApplicationArgs 0
    match main_append_route@5 main_modify_route@6 main_get_route@7

main_after_if_else@11:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    intc_0 // 0
    return

main_get_route@7:
    // tests/artifacts/StateMutations/statemutations.py:66
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_modify_route@6:
    // tests/artifacts/StateMutations/statemutations.py:52
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub modify
    intc_1 // 1
    return

main_append_route@5:
    // tests/artifacts/StateMutations/statemutations.py:39
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub append
    intc_1 // 1
    return

main_bare_routing@8:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn OnCompletion
    switch main___algopy_default_create@10 main_opt_in@9
    b main_after_if_else@11

main_opt_in@9:
    // tests/artifacts/StateMutations/statemutations.py:31
    // @arc4.baremethod(allow_actions=["OptIn"])
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main___algopy_default_create@10:
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    pushbytes ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_replace_dynamic_element(source: bytes, new_item: bytes, index: uint64) -> bytes:
dynamic_array_replace_dynamic_element:
    proto 3 1
    frame_dig -3
    substring 0 2
    dup
    btoi
    frame_dig -3
    extract 2 0
    frame_dig -1
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    frame_dig -1
    intc_1 // 1
    +
    intc_2 // 2
    *
    dup
    cover 4
    dig 2
    swap
    extract_uint16
    dig 2
    len
    dig 4
    frame_dig -1
    -
    intc_1 // 1
    -
    dig 1
    uncover 3
    uncover 2
    select
    dup
    dig 3
    -
    cover 5
    frame_dig -2
    len
    cover 5
    dig 3
    intc_0 // 0
    uncover 4
    substring3
    frame_dig -2
    concat
    uncover 3
    uncover 2
    uncover 3
    substring3
    concat
    swap
    intc_2 // 2
    *

dynamic_array_replace_dynamic_element_for_header@2:
    frame_dig 1
    frame_dig 5
    <
    bz dynamic_array_replace_dynamic_element_after_for@5
    frame_dig 4
    dup
    frame_dig 1
    dup
    cover 3
    extract_uint16
    frame_dig 3
    +
    frame_dig 2
    -
    itob
    extract 6 2
    dig 2
    swap
    replace3
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 1
    b dynamic_array_replace_dynamic_element_for_header@2

dynamic_array_replace_dynamic_element_after_for@5:
    frame_dig 0
    frame_dig 4
    concat
    frame_bury 0
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.opt_in() -> void:
opt_in:
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_3 // "glob_assign"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    bytec 4 // "glob"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    box_put
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    txn Sender
    bytec 5 // "loc"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_del
    pop
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.append() -> void:
append:
    // tests/artifacts/StateMutations/statemutations.py:42
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:45
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.modify() -> void:
modify:
    // tests/artifacts/StateMutations/statemutations.py:56
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:58
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.get() -> bytes:
get:
    // tests/artifacts/StateMutations/statemutations.py:68
    // a0 = self.no_proxy.copy()
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    // tests/artifacts/StateMutations/statemutations.py:69
    // a1 = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:70
    // a2 = self.glob.value.copy()
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    // tests/artifacts/StateMutations/statemutations.py:71
    // a3 = self.loc[Txn.sender].copy()
    txn Sender
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    // tests/artifacts/StateMutations/statemutations.py:72
    // a4 = self.box.value.copy()
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    // tests/artifacts/StateMutations/statemutations.py:73
    // a5 = self.map[Txn.sender].copy()
    bytec 8 // "map"
    txn Sender
    concat
    box_get
    assert // check self.map entry exists
    // tests/artifacts/StateMutations/statemutations.py:75
    // assert a0 == a1, "expected global assign == no_proxy"
    dig 5
    uncover 5
    ==
    assert // expected global assign == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:76
    // assert a0 == a2, "expected global == no_proxy"
    dig 4
    uncover 4
    ==
    assert // expected global == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:77
    // assert a0 == a3, "expected local == no_proxy"
    dig 3
    uncover 3
    ==
    assert // expected local == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:78
    // assert a0 == a4, "expected box == no_proxy"
    dig 2
    uncover 2
    ==
    assert // expected box == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:79
    // assert a0 == a5, "expected map == no_proxy"
    dig 1
    ==
    assert // expected map == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:80
    // return a0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/StateMutations/data/StateMutations.arc56.json b/tests/artifacts/StateMutations/data/StateMutations.arc56.json
index b1fe1cc2..018eeac5 100644
--- a/tests/artifacts/StateMutations/data/StateMutations.arc56.json
+++ b/tests/artifacts/StateMutations/data/StateMutations.arc56.json
@@ -123,17 +123,6 @@
     "sourceInfo": {
         "approval": {
             "sourceInfo": [
-                {
-                    "pc": [
-                        635,
-                        679,
-                        724,
-                        773,
-                        817,
-                        868
-                    ],
-                    "errorMessage": "Index access is out of bounds"
-                },
                 {
                     "pc": [
                         125,
@@ -160,16 +149,16 @@
                 {
                     "pc": [
                         572,
-                        804,
-                        921
+                        840,
+                        975
                     ],
                     "errorMessage": "check self.box exists"
                 },
                 {
                     "pc": [
                         527,
-                        711,
-                        911
+                        729,
+                        965
                     ],
                     "errorMessage": "check self.glob exists"
                 },
@@ -177,63 +166,80 @@
                     "pc": [
                         486,
                         622,
-                        906
+                        960
                     ],
                     "errorMessage": "check self.glob_assign exists"
                 },
                 {
                     "pc": [
                         552,
-                        760,
-                        918
+                        787,
+                        972
                     ],
                     "errorMessage": "check self.loc exists for account"
                 },
                 {
                     "pc": [
                         599,
-                        855,
-                        928
+                        900,
+                        982
                     ],
                     "errorMessage": "check self.map entry exists"
                 },
                 {
                     "pc": [
                         506,
-                        666,
-                        902
+                        675,
+                        956
                     ],
                     "errorMessage": "check self.no_proxy exists"
                 },
                 {
                     "pc": [
-                        952
+                        1006
                     ],
                     "errorMessage": "expected box == no_proxy"
                 },
                 {
                     "pc": [
-                        940
+                        994
                     ],
                     "errorMessage": "expected global == no_proxy"
                 },
                 {
                     "pc": [
-                        934
+                        988
                     ],
                     "errorMessage": "expected global assign == no_proxy"
                 },
                 {
                     "pc": [
-                        946
+                        1000
                     ],
                     "errorMessage": "expected local == no_proxy"
                 },
                 {
                     "pc": [
-                        956
+                        1010
                     ],
                     "errorMessage": "expected map == no_proxy"
+                },
+                {
+                    "pc": [
+                        638,
+                        664,
+                        691,
+                        717,
+                        745,
+                        771,
+                        803,
+                        829,
+                        856,
+                        882,
+                        916,
+                        942
+                    ],
+                    "errorMessage": "index access is out of bounds"
                 }
             ],
             "pcOffsetMethod": "none"
@@ -244,19 +250,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateMutations.statemutations.StateMutations.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock "box" "no_proxy" 0x0000 "glob_assign" "glob" "loc" 0x00020000000000000001000a000362617a 0x00086d6f646966696564 "map"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateMutations/statemutations.py:24
    // self.no_proxy = MyArray()
    bytec_1 // "no_proxy"
    bytec_2 // 0x0000
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@8
    pushbytess 0x526e8bbf 0x95fef13d 0x0c29444b // method "append()void", method "modify()void", method "get()(uint64,string)[]"
    txna ApplicationArgs 0
    match main_append_route@5 main_modify_route@6 main_get_route@7

main_after_if_else@11:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    intc_0 // 0
    return

main_get_route@7:
    // tests/artifacts/StateMutations/statemutations.py:66
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_modify_route@6:
    // tests/artifacts/StateMutations/statemutations.py:52
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub modify
    intc_1 // 1
    return

main_append_route@5:
    // tests/artifacts/StateMutations/statemutations.py:39
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub append
    intc_1 // 1
    return

main_bare_routing@8:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn OnCompletion
    switch main___algopy_default_create@10 main_opt_in@9
    b main_after_if_else@11

main_opt_in@9:
    // tests/artifacts/StateMutations/statemutations.py:31
    // @arc4.baremethod(allow_actions=["OptIn"])
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main___algopy_default_create@10:
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    pushbytes ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_replace_dynamic_element(source: bytes, new_item: bytes, index: uint64) -> bytes:
dynamic_array_replace_dynamic_element:
    proto 3 1
    frame_dig -3
    substring 0 2
    dup
    btoi
    frame_dig -3
    extract 2 0
    frame_dig -1
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    frame_dig -1
    intc_1 // 1
    +
    intc_2 // 2
    *
    dup
    cover 4
    dig 2
    swap
    extract_uint16
    dig 2
    len
    dig 4
    frame_dig -1
    -
    intc_1 // 1
    -
    dig 1
    uncover 3
    uncover 2
    select
    dup
    dig 3
    -
    cover 5
    frame_dig -2
    len
    cover 5
    dig 3
    intc_0 // 0
    uncover 4
    substring3
    frame_dig -2
    concat
    uncover 3
    uncover 2
    uncover 3
    substring3
    concat
    swap
    intc_2 // 2
    *

dynamic_array_replace_dynamic_element_for_header@2:
    frame_dig 1
    frame_dig 5
    <
    bz dynamic_array_replace_dynamic_element_after_for@5
    frame_dig 4
    dup
    frame_dig 1
    dup
    cover 3
    extract_uint16
    frame_dig 3
    +
    frame_dig 2
    -
    itob
    extract 6 2
    dig 2
    swap
    replace3
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 1
    b dynamic_array_replace_dynamic_element_for_header@2

dynamic_array_replace_dynamic_element_after_for@5:
    frame_dig 0
    frame_dig 4
    concat
    frame_bury 0
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.opt_in() -> void:
opt_in:
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_3 // "glob_assign"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    bytec 4 // "glob"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    bytec_2 // 0x0000
    box_put
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    txn Sender
    bytec 5 // "loc"
    bytec_2 // 0x0000
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_del
    pop
    bytec_2 // 0x0000
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.append() -> void:
append:
    // tests/artifacts/StateMutations/statemutations.py:42
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:45
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.modify() -> void:
modify:
    // tests/artifacts/StateMutations/statemutations.py:56
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:58
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    extract 2 0
    dup
    intc_0 // 0
    extract_uint16
    dig 2
    intc_0 // 0
    extract_uint16
    intc_1 // 1
    - // on error: Index access is out of bounds
    dig 2
    len
    dig 3
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    concat
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.get() -> bytes:
get:
    // tests/artifacts/StateMutations/statemutations.py:68
    // a0 = self.no_proxy.copy()
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    // tests/artifacts/StateMutations/statemutations.py:69
    // a1 = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:70
    // a2 = self.glob.value.copy()
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    // tests/artifacts/StateMutations/statemutations.py:71
    // a3 = self.loc[Txn.sender].copy()
    txn Sender
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    // tests/artifacts/StateMutations/statemutations.py:72
    // a4 = self.box.value.copy()
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    // tests/artifacts/StateMutations/statemutations.py:73
    // a5 = self.map[Txn.sender].copy()
    bytec 8 // "map"
    txn Sender
    concat
    box_get
    assert // check self.map entry exists
    // tests/artifacts/StateMutations/statemutations.py:75
    // assert a0 == a1, "expected global assign == no_proxy"
    dig 5
    uncover 5
    ==
    assert // expected global assign == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:76
    // assert a0 == a2, "expected global == no_proxy"
    dig 4
    uncover 4
    ==
    assert // expected global == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:77
    // assert a0 == a3, "expected local == no_proxy"
    dig 3
    uncover 3
    ==
    assert // expected local == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:78
    // assert a0 == a4, "expected box == no_proxy"
    dig 2
    uncover 2
    ==
    assert // expected box == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:79
    // assert a0 == a5, "expected map == no_proxy"
    dig 1
    ==
    assert // expected map == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:80
    // return a0
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateMutations.statemutations.StateMutations.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1 2 8
    bytecblock "box" "no_proxy" 0x0000 "glob_assign" "glob" "loc" 0x00020000000000000001000a000362617a 0x00086d6f646966696564 "map"
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateMutations/statemutations.py:24
    // self.no_proxy = MyArray()
    bytec_1 // "no_proxy"
    bytec_2 // 0x0000
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@8
    pushbytess 0x526e8bbf 0x95fef13d 0x0c29444b // method "append()void", method "modify()void", method "get()(uint64,string)[]"
    txna ApplicationArgs 0
    match main_append_route@5 main_modify_route@6 main_get_route@7

main_after_if_else@11:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    intc_0 // 0
    return

main_get_route@7:
    // tests/artifacts/StateMutations/statemutations.py:66
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_modify_route@6:
    // tests/artifacts/StateMutations/statemutations.py:52
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub modify
    intc_1 // 1
    return

main_append_route@5:
    // tests/artifacts/StateMutations/statemutations.py:39
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub append
    intc_1 // 1
    return

main_bare_routing@8:
    // tests/artifacts/StateMutations/statemutations.py:22
    // class StateMutations(ARC4Contract):
    txn OnCompletion
    switch main___algopy_default_create@10 main_opt_in@9
    b main_after_if_else@11

main_opt_in@9:
    // tests/artifacts/StateMutations/statemutations.py:31
    // @arc4.baremethod(allow_actions=["OptIn"])
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main___algopy_default_create@10:
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// _puya_lib.arc4.dynamic_array_concat_dynamic_element(array_items_count: uint64, array_head_and_tail: bytes, new_items_count: uint64, new_head_and_tail: bytes) -> bytes:
dynamic_array_concat_dynamic_element:
    proto 4 1
    pushbytes ""
    dup
    frame_dig -2
    intc_2 // 2
    *
    frame_dig -4
    intc_2 // 2
    *
    intc_0 // 0

dynamic_array_concat_dynamic_element_for_header@1:
    frame_dig 4
    frame_dig 3
    <
    bz dynamic_array_concat_dynamic_element_after_for@4
    frame_dig -3
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 2
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@1

dynamic_array_concat_dynamic_element_after_for@4:
    frame_dig -3
    len
    frame_bury 0
    intc_0 // 0
    frame_bury 4

dynamic_array_concat_dynamic_element_for_header@5:
    frame_dig 4
    frame_dig 2
    <
    bz dynamic_array_concat_dynamic_element_after_for@8
    frame_dig -1
    frame_dig 4
    dup
    cover 2
    extract_uint16
    frame_dig 0
    +
    itob
    extract 6 2
    frame_dig 1
    swap
    concat
    frame_bury 1
    intc_2 // 2
    +
    frame_bury 4
    b dynamic_array_concat_dynamic_element_for_header@5

dynamic_array_concat_dynamic_element_after_for@8:
    frame_dig -4
    frame_dig -2
    +
    itob
    extract 6 2
    frame_dig 1
    concat
    frame_dig -3
    frame_dig 3
    frame_dig 0
    substring3
    concat
    frame_dig -1
    len
    frame_dig -1
    frame_dig 2
    uncover 2
    substring3
    concat
    frame_bury 0
    retsub


// _puya_lib.arc4.dynamic_array_replace_dynamic_element(source: bytes, new_item: bytes, index: uint64) -> bytes:
dynamic_array_replace_dynamic_element:
    proto 3 1
    frame_dig -3
    substring 0 2
    dup
    btoi
    frame_dig -3
    extract 2 0
    frame_dig -1
    intc_2 // 2
    *
    dig 1
    swap
    extract_uint16
    frame_dig -1
    intc_1 // 1
    +
    intc_2 // 2
    *
    dup
    cover 4
    dig 2
    swap
    extract_uint16
    dig 2
    len
    dig 4
    frame_dig -1
    -
    intc_1 // 1
    -
    dig 1
    uncover 3
    uncover 2
    select
    dup
    dig 3
    -
    cover 5
    frame_dig -2
    len
    cover 5
    dig 3
    intc_0 // 0
    uncover 4
    substring3
    frame_dig -2
    concat
    uncover 3
    uncover 2
    uncover 3
    substring3
    concat
    swap
    intc_2 // 2
    *

dynamic_array_replace_dynamic_element_for_header@2:
    frame_dig 1
    frame_dig 5
    <
    bz dynamic_array_replace_dynamic_element_after_for@5
    frame_dig 4
    dup
    frame_dig 1
    dup
    cover 3
    extract_uint16
    frame_dig 3
    +
    frame_dig 2
    -
    itob
    extract 6 2
    dig 2
    swap
    replace3
    frame_bury 4
    intc_2 // 2
    +
    frame_bury 1
    b dynamic_array_replace_dynamic_element_for_header@2

dynamic_array_replace_dynamic_element_after_for@5:
    frame_dig 0
    frame_dig 4
    concat
    frame_bury 0
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.opt_in() -> void:
opt_in:
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_3 // "glob_assign"
    bytec_2 // 0x0000
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    bytec 4 // "glob"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:34
    // self.glob.value = MyArray()
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:35
    // self.box.value = MyArray()
    box_put
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    txn Sender
    bytec 5 // "loc"
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:36
    // self.loc[Txn.sender] = MyArray()
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_del
    pop
    // tests/artifacts/StateMutations/statemutations.py:33
    // self.glob_assign.value = MyArray()
    bytec_2 // 0x0000
    // tests/artifacts/StateMutations/statemutations.py:37
    // self.map[Txn.sender] = MyArray()
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.append() -> void:
append:
    // tests/artifacts/StateMutations/statemutations.py:42
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    bytec 6 // 0x00020000000000000001000a000362617a
    callsub dynamic_array_concat_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:45
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:46
    // self.no_proxy.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:47
    // self.glob.value.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:48
    // self.loc[Txn.sender].append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:49
    // self.box.value.append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    intc_0 // 0
    extract_uint16
    swap
    extract 2 0
    intc_1 // 1
    // tests/artifacts/StateMutations/statemutations.py:43
    // arr.append(struct.copy())
    bytec 6 // 0x00020000000000000001000a000362617a
    // tests/artifacts/StateMutations/statemutations.py:50
    // self.map[Txn.sender].append(struct.copy())
    callsub dynamic_array_concat_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.modify() -> void:
modify:
    // tests/artifacts/StateMutations/statemutations.py:56
    // arr = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:57
    // arr[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    // tests/artifacts/StateMutations/statemutations.py:58
    // self.glob_assign.value = arr.copy()
    bytec_3 // "glob_assign"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:60
    // self.no_proxy[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_1 // "no_proxy"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:61
    // self.glob.value[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 4 // "glob"
    swap
    app_global_put
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    txn Sender
    dup
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:62
    // self.loc[Txn.sender][0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec 5 // "loc"
    swap
    app_local_put
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:63
    // self.box.value[0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    bytec_0 // "box"
    box_del
    pop
    bytec_0 // "box"
    swap
    box_put
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    bytec 8 // "map"
    txn Sender
    concat
    dup
    box_get
    assert // check self.map entry exists
    dup
    extract 2 0
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_0 // 0
    extract_uint16
    dig 1
    intc_1 // 1
    - // on error: index access is out of bounds
    dig 3
    len
    dig 4
    intc_2 // 2
    extract_uint16
    uncover 2
    select
    uncover 3
    cover 2
    substring3
    dup
    intc_3 // 8
    extract_uint16
    intc_0 // 0
    swap
    extract3
    // tests/artifacts/StateMutations/statemutations.py:54
    // modified = arc4.String("modified")
    bytec 7 // 0x00086d6f646966696564
    // tests/artifacts/StateMutations/statemutations.py:64
    // self.map[Txn.sender][0].baz = modified
    concat
    swap
    assert // index access is out of bounds
    intc_0 // 0
    callsub dynamic_array_replace_dynamic_element
    dig 1
    box_del
    pop
    box_put
    retsub


// tests.artifacts.StateMutations.statemutations.StateMutations.get() -> bytes:
get:
    // tests/artifacts/StateMutations/statemutations.py:68
    // a0 = self.no_proxy.copy()
    intc_0 // 0
    bytec_1 // "no_proxy"
    app_global_get_ex
    assert // check self.no_proxy exists
    // tests/artifacts/StateMutations/statemutations.py:69
    // a1 = self.glob_assign.value.copy()
    intc_0 // 0
    bytec_3 // "glob_assign"
    app_global_get_ex
    assert // check self.glob_assign exists
    // tests/artifacts/StateMutations/statemutations.py:70
    // a2 = self.glob.value.copy()
    intc_0 // 0
    bytec 4 // "glob"
    app_global_get_ex
    assert // check self.glob exists
    // tests/artifacts/StateMutations/statemutations.py:71
    // a3 = self.loc[Txn.sender].copy()
    txn Sender
    intc_0 // 0
    bytec 5 // "loc"
    app_local_get_ex
    assert // check self.loc exists for account
    // tests/artifacts/StateMutations/statemutations.py:72
    // a4 = self.box.value.copy()
    bytec_0 // "box"
    box_get
    assert // check self.box exists
    // tests/artifacts/StateMutations/statemutations.py:73
    // a5 = self.map[Txn.sender].copy()
    bytec 8 // "map"
    txn Sender
    concat
    box_get
    assert // check self.map entry exists
    // tests/artifacts/StateMutations/statemutations.py:75
    // assert a0 == a1, "expected global assign == no_proxy"
    dig 5
    uncover 5
    ==
    assert // expected global assign == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:76
    // assert a0 == a2, "expected global == no_proxy"
    dig 4
    uncover 4
    ==
    assert // expected global == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:77
    // assert a0 == a3, "expected local == no_proxy"
    dig 3
    uncover 3
    ==
    assert // expected local == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:78
    // assert a0 == a4, "expected box == no_proxy"
    dig 2
    uncover 2
    ==
    assert // expected box == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:79
    // assert a0 == a5, "expected map == no_proxy"
    dig 1
    ==
    assert // expected map == no_proxy
    // tests/artifacts/StateMutations/statemutations.py:80
    // return a0
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "CiAEAAECCCYJA2JveAhub19wcm94eQIAAAtnbG9iX2Fzc2lnbgRnbG9iA2xvYxEAAgAAAAAAAAABAAoAA2JhegoACG1vZGlmaWVkA21hcDEYQAADKSpnMRtBAEuCAwRSbou/BJX+8T0EDClESzYaAI4DACMAFwACIkMxGRREMRhEiAL/gAQVH3x1TFCwI0MxGRREMRhEiAHSI0MxGRREMRhEiAE+I0MxGY0CAAsAA0L/xjEYRIgBDSNDMRgURCNDigQBgABJi/4kC4v8JAsiiwSLAwxBAByL/YsESU4CWYsCCBZXBgKLAUxQjAEkCIwEQv/ci/0VjAAijASLBIsCDEEAHIv/iwRJTgJZiwAIFlcGAosBTFCMASQIjARC/9yL/Iv+CBZXBgKLAVCL/YsDiwBSUIv/FYv/iwJPAlJQjACJigMBi/1RAAJJF4v9VwIAi/8kC0sBTFmL/yMIJAtJTgRLAkxZSwIVSwSL/wkjCUsBTwNPAk1JSwMJTgWL/hVOBUsDIk8EUov+UE8DTwJPA1JQTCQLiwGLBQxBACCLBEmLAUlOA1mLAwiLAgkWVwYCSwJMXYwEJAiMAUL/2IsAiwRQjACJKypnJwQqZyi8SCgqvzEAJwUqZicIMQBQSbxIKr+JIitlREkiWUxXAgAjJwaI/swrTGciKWVESSJZTFcCACMnBoj+uClMZyInBGVESSJZTFcCACMnBoj+oycETGcxAEkiJwVjREkiWUxXAgAjJwaI/oonBUxmKL5ESSJZTFcCACMnBoj+dii8SChMvycIMQBQSb5ESSJZTFcCACMnBoj+W0sBvEi/iSIrZURJVwIASSJZSwIiWSMJSwIVSwMkWU8CTVJJJVkiTFgnB1AiiP6tK0xnIillRElXAgBJIllLAiJZIwlLAhVLAyRZTwJNUkklWSJMWCcHUCKI/oEpTGciJwRlRElXAgBJIllLAiJZIwlLAhVLAyRZTwJNUkklWSJMWCcHUCKI/lQnBExnMQBJIicFY0RJVwIASSJZSwIiWSMJSwIVSwMkWU8CTVJJJVkiTFgnB1AiiP4jJwVMZii+RElXAgBJIllLAiJZIwlLAhVLAyRZTwJNUkklWSJMWCcHUCKI/fcovEgoTL8nCDEAUEm+RElXAgBJIllLAiJZIwlLAhVLAyRZTwJNUkklWSJMWCcHUCKI/cRLAbxIv4kiKWVEIitlRCInBGVEMQAiJwVjRCi+RCcIMQBQvkRLBU8FEkRLBE8EEkRLA08DEkRLAk8CEkRLARJEiQ==",
+        "approval": "CiAEAAECCCYJA2JveAhub19wcm94eQIAAAtnbG9iX2Fzc2lnbgRnbG9iA2xvYxEAAgAAAAAAAAABAAoAA2JhegoACG1vZGlmaWVkA21hcDEYQAADKSpnMRtBAEuCAwRSbou/BJX+8T0EDClESzYaAI4DACMAFwACIkMxGRREMRhEiAM1gAQVH3x1TFCwI0MxGRREMRhEiAHSI0MxGRREMRhEiAE+I0MxGY0CAAsAA0L/xjEYRIgBDSNDMRgURCNDigQBgABJi/4kC4v8JAsiiwSLAwxBAByL/YsESU4CWYsCCBZXBgKLAUxQjAEkCIwEQv/ci/0VjAAijASLBIsCDEEAHIv/iwRJTgJZiwAIFlcGAosBTFCMASQIjARC/9yL/Iv+CBZXBgKLAVCL/YsDiwBSUIv/FYv/iwJPAlJQjACJigMBi/1RAAJJF4v9VwIAi/8kC0sBTFmL/yMIJAtJTgRLAkxZSwIVSwSL/wkjCUsBTwNPAk1JSwMJTgWL/hVOBUsDIk8EUov+UE8DTwJPA1JQTCQLiwGLBQxBACCLBEmLAUlOA1mLAwiLAgkWVwYCSwJMXYwEJAiMAUL/2IsAiwRQjACJKypnJwQqZyi8SCgqvzEAJwUqZicIMQBQSbxIKr+JIitlREkiWUxXAgAjJwaI/swrTGciKWVESSJZTFcCACMnBoj+uClMZyInBGVESSJZTFcCACMnBoj+oycETGcxAEkiJwVjREkiWUxXAgAjJwaI/oonBUxmKL5ESSJZTFcCACMnBoj+dii8SChMvycIMQBQSb5ESSJZTFcCACMnBoj+W0sBvEi/iSIrZURJVwIASwEiWUsBIllLASMJSwMVSwQkWU8CTU8DTgJSSSVZIkxYJwdQTEQiiP6kK0xnIillRElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/m8pTGciJwRlRElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/jknBExnMQBJIicFY0RJVwIASwEiWUsBIllLASMJSwMVSwQkWU8CTU8DTgJSSSVZIkxYJwdQTEQiiP3/JwVMZii+RElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/coovEgoTL8nCDEAUEm+RElXAgBLASJZSwEiWUsBIwlLAxVLBCRZTwJNTwNOAlJJJVkiTFgnB1BMRCKI/Y5LAbxIv4kiKWVEIitlRCInBGVEMQAiJwVjRCi+RCcIMQBQvkRLBU8FEkRLBE8EEkRLA08DEkRLAk8CEkRLARJEiQ==",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal b/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal
index 55643c6d..26c1c54d 100644
--- a/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal
+++ b/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal
@@ -57,7 +57,11 @@ main:
     // tests/artifacts/StateOps/contract.py:527
     // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
     bytec 11 // "explicit_key_arc4_string"
+    // tests/artifacts/StateOps/contract.py:517
+    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
     bytec 18 // 0x000548656c6c6f
+    // tests/artifacts/StateOps/contract.py:527
+    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
     app_global_put
     // tests/artifacts/StateOps/contract.py:528
     // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
@@ -67,7 +71,11 @@ main:
     // tests/artifacts/StateOps/contract.py:529
     // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
     bytec 13 // "explicit_key_arc4_bool"
+    // tests/artifacts/StateOps/contract.py:519
+    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
     pushbytes 0x80
+    // tests/artifacts/StateOps/contract.py:529
+    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
     app_global_put
     // tests/artifacts/StateOps/contract.py:531
     // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
@@ -86,6 +94,8 @@ main:
     // tests/artifacts/StateOps/contract.py:535
     // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
     bytec 16 // "explicit_key_arc4_dynamic_bytes"
+    // tests/artifacts/StateOps/contract.py:522
+    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
     bytec 20 // 0x000d64796e616d6963206279746573
     // tests/artifacts/StateOps/contract.py:534-536
     // self.arc4_dynamic_bytes = GlobalState(
@@ -255,12 +265,6 @@ main_set_implicit_key_tuple_route@27:
     uncover 2
     intc_3 // 80
     getbit
-    bytec_1 // 0x00
-    intc_1 // 0
-    uncover 2
-    setbit
-    intc_1 // 0
-    getbit
     // tests/artifacts/StateOps/contract.py:629
     // @arc4.abimethod()
     callsub set_implicit_key_tuple
@@ -518,14 +522,13 @@ main_get_implicit_key_tuple_route@12:
     extract 6 2
     uncover 3
     concat
+    swap
+    bytec 21 // 0x000b
+    concat
     bytec_1 // 0x00
     intc_1 // 0
     uncover 4
     setbit
-    uncover 2
-    bytec 21 // 0x000b
-    concat
-    swap
     concat
     swap
     concat
@@ -761,12 +764,6 @@ get_implicit_key_tuple:
     uncover 2
     intc_3 // 80
     getbit
-    bytec_1 // 0x00
-    intc_1 // 0
-    uncover 2
-    setbit
-    intc_1 // 0
-    getbit
     retsub
 
 
@@ -952,8 +949,8 @@ set_implicit_key_tuple:
     // @arc4.abimethod()
     // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
     proto 3 0
-    // tests/artifacts/StateOps/contract.py:630
-    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
+    // tests/artifacts/StateOps/contract.py:631
+    // self.implicit_key_tuple.value = value
     frame_dig -3
     itob
     frame_dig -2
@@ -962,16 +959,13 @@ set_implicit_key_tuple:
     extract 6 2
     frame_dig -2
     concat
+    swap
+    bytec 21 // 0x000b
+    concat
     bytec_1 // 0x00
     intc_1 // 0
     frame_dig -1
     setbit
-    // tests/artifacts/StateOps/contract.py:631
-    // self.implicit_key_tuple.value = value
-    uncover 2
-    bytec 21 // 0x000b
-    concat
-    swap
     concat
     swap
     concat
diff --git a/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json b/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json
index 95f96eb6..f7262b76 100644
--- a/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json
+++ b/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json
@@ -152,7 +152,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.GlobalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0 8 80
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" "implicit_key_arc4_string" "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" "implicit_key_arc4_dynamic_bytes" "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes" 0x0000000000000539 0x000548656c6c6f 0x00000010000000000000000000000000 0x000d64796e616d6963206279746573 0x000b
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateOps/contract.py:515-516
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    bytec_2 // "implicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec_3 // "implicit_key_arc4_string"
    bytec 18 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:518
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    bytec 4 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    bytec 5 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:520
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    bytec 6 // "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:521
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    bytec 7 // "implicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    bytec 20 // 0x000d64796e616d6963206279746573
    app_global_put
    // tests/artifacts/StateOps/contract.py:523
    // self.implicit_key_tuple = GlobalState((UInt64(10), Bytes(b"test"), False))
    bytec 9 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_global_put
    // tests/artifacts/StateOps/contract.py:525-526
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    bytec 10 // "explicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    bytec 11 // "explicit_key_arc4_string"
    bytec 18 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:528
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    bytec 12 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    bytec 13 // "explicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:531
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    bytec 14 // "explicit_key_arc4_address"
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:530-532
    // self.arc4_address = GlobalState(
    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    // )
    app_global_put
    // tests/artifacts/StateOps/contract.py:533
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    bytec 15 // "explicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:535
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    bytec 20 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:534-536
    // self.arc4_dynamic_bytes = GlobalState(
    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    // )
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@35
    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x166c6afd 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 0x461afc6d 0x048116ea 0x30e34a93 0xd2e646ef 0xe674a270 0xa87e540d 0x720a3ca0 0x257708f7 // method "get_implicit_key_arc4_uint()uint64", method "get_implicit_key_arc4_string()string", method "get_implicit_key_arc4_byte()byte", method "get_implicit_key_arc4_bool()bool", method "get_implicit_key_arc4_address()address", method "get_implicit_key_arc4_uint128()uint128", method "get_implicit_key_arc4_dynamic_bytes()byte[]", method "get_implicit_key_tuple()(uint64,byte[],bool)", method "get_arc4_uint()uint64", method "get_arc4_string()string", method "get_arc4_byte()byte", method "get_arc4_bool()bool", method "get_arc4_address()address", method "get_arc4_uint128()uint128", method "get_arc4_dynamic_bytes()byte[]", method "set_implicit_key_arc4_uint(uint64)void", method "set_implicit_key_arc4_string(string)void", method "set_implicit_key_arc4_byte(byte)void", method "set_implicit_key_arc4_bool(bool)void", method "set_implicit_key_arc4_address(address)void", method "set_implicit_key_arc4_uint128(uint128)void", method "set_implicit_key_arc4_dynamic_bytes(byte[])void", method "set_implicit_key_tuple((uint64,byte[],bool))void", method "set_arc4_uint(uint64)void", method "set_arc4_string(string)void", method "set_arc4_byte(byte)void", method "set_arc4_bool(bool)void", method "set_arc4_address(address)void", method "set_arc4_uint128(uint128)void", method "set_arc4_dynamic_bytes(byte[])void"
    txna ApplicationArgs 0
    match main_get_implicit_key_arc4_uint_route@5 main_get_implicit_key_arc4_string_route@6 main_get_implicit_key_arc4_byte_route@7 main_get_implicit_key_arc4_bool_route@8 main_get_implicit_key_arc4_address_route@9 main_get_implicit_key_arc4_uint128_route@10 main_get_implicit_key_arc4_dynamic_bytes_route@11 main_get_implicit_key_tuple_route@12 main_get_arc4_uint_route@13 main_get_arc4_string_route@14 main_get_arc4_byte_route@15 main_get_arc4_bool_route@16 main_get_arc4_address_route@17 main_get_arc4_uint128_route@18 main_get_arc4_dynamic_bytes_route@19 main_set_implicit_key_arc4_uint_route@20 main_set_implicit_key_arc4_string_route@21 main_set_implicit_key_arc4_byte_route@22 main_set_implicit_key_arc4_bool_route@23 main_set_implicit_key_arc4_address_route@24 main_set_implicit_key_arc4_uint128_route@25 main_set_implicit_key_arc4_dynamic_bytes_route@26 main_set_implicit_key_tuple_route@27 main_set_arc4_uint_route@28 main_set_arc4_string_route@29 main_set_arc4_byte_route@30 main_set_arc4_bool_route@31 main_set_arc4_address_route@32 main_set_arc4_uint128_route@33 main_set_arc4_dynamic_bytes_route@34

main_after_if_else@37:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    intc_1 // 0
    return

main_set_arc4_dynamic_bytes_route@34:
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    callsub set_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_arc4_uint128_route@33:
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    callsub set_arc4_uint128
    intc_0 // 1
    return

main_set_arc4_address_route@32:
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    callsub set_arc4_address
    intc_0 // 1
    return

main_set_arc4_bool_route@31:
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    callsub set_arc4_bool
    intc_0 // 1
    return

main_set_arc4_byte_route@30:
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    callsub set_arc4_byte
    intc_0 // 1
    return

main_set_arc4_string_route@29:
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    callsub set_arc4_string
    intc_0 // 1
    return

main_set_arc4_uint_route@28:
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    callsub set_arc4_uint
    intc_0 // 1
    return

main_set_implicit_key_tuple_route@27:
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    intc_1 // 0
    getbit
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    callsub set_implicit_key_tuple
    intc_0 // 1
    return

main_set_implicit_key_arc4_dynamic_bytes_route@26:
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint128_route@25:
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint128
    intc_0 // 1
    return

main_set_implicit_key_arc4_address_route@24:
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_address
    intc_0 // 1
    return

main_set_implicit_key_arc4_bool_route@23:
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_bool
    intc_0 // 1
    return

main_set_implicit_key_arc4_byte_route@22:
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_byte
    intc_0 // 1
    return

main_set_implicit_key_arc4_string_route@21:
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_string
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint_route@20:
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint
    intc_0 // 1
    return

main_get_arc4_dynamic_bytes_route@19:
    // tests/artifacts/StateOps/contract.py:596
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint128_route@18:
    // tests/artifacts/StateOps/contract.py:592
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_address_route@17:
    // tests/artifacts/StateOps/contract.py:588
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_bool_route@16:
    // tests/artifacts/StateOps/contract.py:584
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_byte_route@15:
    // tests/artifacts/StateOps/contract.py:580
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_string_route@14:
    // tests/artifacts/StateOps/contract.py:576
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint_route@13:
    // tests/artifacts/StateOps/contract.py:571-572
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_tuple_route@12:
    // tests/artifacts/StateOps/contract.py:567
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    bytec_1 // 0x00
    intc_1 // 0
    uncover 4
    setbit
    uncover 2
    bytec 21 // 0x000b
    concat
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@11:
    // tests/artifacts/StateOps/contract.py:563
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint128_route@10:
    // tests/artifacts/StateOps/contract.py:559
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_address_route@9:
    // tests/artifacts/StateOps/contract.py:555
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_bool_route@8:
    // tests/artifacts/StateOps/contract.py:551
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_byte_route@7:
    // tests/artifacts/StateOps/contract.py:547
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_string_route@6:
    // tests/artifacts/StateOps/contract.py:543
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint_route@5:
    // tests/artifacts/StateOps/contract.py:538-539
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@35:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@37
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint() -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_uint.value
    intc_1 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_string() -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:545
    // return self.implicit_key_arc4_string.value
    intc_1 // 0
    bytec_3 // "implicit_key_arc4_string"
    app_global_get_ex
    assert // check self.implicit_key_arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_byte() -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:549
    // return self.implicit_key_arc4_byte.value
    intc_1 // 0
    bytec 4 // "implicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.implicit_key_arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_bool() -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:553
    // return self.implicit_key_arc4_bool.value
    intc_1 // 0
    bytec 5 // "implicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.implicit_key_arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_address() -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:557
    // return self.implicit_key_arc4_address.value
    intc_1 // 0
    bytec 6 // "implicit_key_arc4_address"
    app_global_get_ex
    assert // check self.implicit_key_arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint128() -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:561
    // return self.implicit_key_arc4_uint128.value
    intc_1 // 0
    bytec 7 // "implicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_dynamic_bytes() -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:565
    // return self.implicit_key_arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_tuple() -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:569
    // return self.implicit_key_tuple.value
    intc_1 // 0
    bytec 9 // "implicit_key_tuple"
    app_global_get_ex
    assert // check self.implicit_key_tuple exists
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    intc_1 // 0
    getbit
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint() -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:574
    // return self.arc4_uint.value
    intc_1 // 0
    bytec 10 // "explicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_string() -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:578
    // return self.arc4_string.value
    intc_1 // 0
    bytec 11 // "explicit_key_arc4_string"
    app_global_get_ex
    assert // check self.arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_byte() -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:582
    // return self.arc4_byte.value
    intc_1 // 0
    bytec 12 // "explicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_bool() -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:586
    // return self.arc4_bool.value
    intc_1 // 0
    bytec 13 // "explicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_address() -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:590
    // return self.arc4_address.value
    intc_1 // 0
    bytec 14 // "explicit_key_arc4_address"
    app_global_get_ex
    assert // check self.arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint128() -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:594
    // return self.arc4_uint128.value
    intc_1 // 0
    bytec 15 // "explicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_dynamic_bytes() -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:598
    // return self.arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint(value: bytes) -> void:
set_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:600-602
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_uint.value = value
    bytec_2 // "implicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_string(value: bytes) -> void:
set_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:605-606
    // @arc4.abimethod()
    // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_string.value = value
    bytec_3 // "implicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_byte(value: bytes) -> void:
set_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:609-610
    // @arc4.abimethod()
    // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_byte.value = value
    bytec 4 // "implicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_bool(value: bytes) -> void:
set_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:613-614
    // @arc4.abimethod()
    // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_bool.value = value
    bytec 5 // "implicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_address(value: bytes) -> void:
set_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:617-618
    // @arc4.abimethod()
    // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_address.value = value
    bytec 6 // "implicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint128(value: bytes) -> void:
set_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:621-622
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_uint128.value = value
    bytec 7 // "implicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_dynamic_bytes(value: bytes) -> void:
set_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:625-626
    // @arc4.abimethod()
    // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:627
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_tuple(value.0: uint64, value.1: bytes, value.2: uint64) -> void:
set_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:629-630
    // @arc4.abimethod()
    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:630
    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
    frame_dig -3
    itob
    frame_dig -2
    len
    itob
    extract 6 2
    frame_dig -2
    concat
    bytec_1 // 0x00
    intc_1 // 0
    frame_dig -1
    setbit
    // tests/artifacts/StateOps/contract.py:631
    // self.implicit_key_tuple.value = value
    uncover 2
    bytec 21 // 0x000b
    concat
    swap
    concat
    swap
    concat
    bytec 9 // "implicit_key_tuple"
    swap
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:633-635
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    // def set_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_uint.value = value
    bytec 10 // "explicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_string(value: bytes) -> void:
set_arc4_string:
    // tests/artifacts/StateOps/contract.py:638-639
    // @arc4.abimethod()
    // def set_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_string.value = value
    bytec 11 // "explicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_byte(value: bytes) -> void:
set_arc4_byte:
    // tests/artifacts/StateOps/contract.py:642-643
    // @arc4.abimethod()
    // def set_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_byte.value = value
    bytec 12 // "explicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_bool(value: bytes) -> void:
set_arc4_bool:
    // tests/artifacts/StateOps/contract.py:646-647
    // @arc4.abimethod()
    // def set_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_bool.value = value
    bytec 13 // "explicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_address(value: bytes) -> void:
set_arc4_address:
    // tests/artifacts/StateOps/contract.py:650-651
    // @arc4.abimethod()
    // def set_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_address.value = value
    bytec 14 // "explicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint128(value: bytes) -> void:
set_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:654-655
    // @arc4.abimethod()
    // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:656
    // self.arc4_uint128.value = value
    bytec 15 // "explicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_dynamic_bytes(value: bytes) -> void:
set_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:658-659
    // @arc4.abimethod()
    // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:660
    // self.arc4_dynamic_bytes.value = value.copy()
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.GlobalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0 8 80
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" "implicit_key_arc4_string" "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" "implicit_key_arc4_dynamic_bytes" "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes" 0x0000000000000539 0x000548656c6c6f 0x00000010000000000000000000000000 0x000d64796e616d6963206279746573 0x000b
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateOps/contract.py:515-516
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    bytec_2 // "implicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec_3 // "implicit_key_arc4_string"
    bytec 18 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:518
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    bytec 4 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    bytec 5 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:520
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    bytec 6 // "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:521
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    bytec 7 // "implicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    bytec 20 // 0x000d64796e616d6963206279746573
    app_global_put
    // tests/artifacts/StateOps/contract.py:523
    // self.implicit_key_tuple = GlobalState((UInt64(10), Bytes(b"test"), False))
    bytec 9 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_global_put
    // tests/artifacts/StateOps/contract.py:525-526
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    bytec 10 // "explicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    bytec 11 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec 18 // 0x000548656c6c6f
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    app_global_put
    // tests/artifacts/StateOps/contract.py:528
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    bytec 12 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    bytec 13 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    pushbytes 0x80
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    app_global_put
    // tests/artifacts/StateOps/contract.py:531
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    bytec 14 // "explicit_key_arc4_address"
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:530-532
    // self.arc4_address = GlobalState(
    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    // )
    app_global_put
    // tests/artifacts/StateOps/contract.py:533
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    bytec 15 // "explicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:535
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 20 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:534-536
    // self.arc4_dynamic_bytes = GlobalState(
    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    // )
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@35
    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x166c6afd 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 0x461afc6d 0x048116ea 0x30e34a93 0xd2e646ef 0xe674a270 0xa87e540d 0x720a3ca0 0x257708f7 // method "get_implicit_key_arc4_uint()uint64", method "get_implicit_key_arc4_string()string", method "get_implicit_key_arc4_byte()byte", method "get_implicit_key_arc4_bool()bool", method "get_implicit_key_arc4_address()address", method "get_implicit_key_arc4_uint128()uint128", method "get_implicit_key_arc4_dynamic_bytes()byte[]", method "get_implicit_key_tuple()(uint64,byte[],bool)", method "get_arc4_uint()uint64", method "get_arc4_string()string", method "get_arc4_byte()byte", method "get_arc4_bool()bool", method "get_arc4_address()address", method "get_arc4_uint128()uint128", method "get_arc4_dynamic_bytes()byte[]", method "set_implicit_key_arc4_uint(uint64)void", method "set_implicit_key_arc4_string(string)void", method "set_implicit_key_arc4_byte(byte)void", method "set_implicit_key_arc4_bool(bool)void", method "set_implicit_key_arc4_address(address)void", method "set_implicit_key_arc4_uint128(uint128)void", method "set_implicit_key_arc4_dynamic_bytes(byte[])void", method "set_implicit_key_tuple((uint64,byte[],bool))void", method "set_arc4_uint(uint64)void", method "set_arc4_string(string)void", method "set_arc4_byte(byte)void", method "set_arc4_bool(bool)void", method "set_arc4_address(address)void", method "set_arc4_uint128(uint128)void", method "set_arc4_dynamic_bytes(byte[])void"
    txna ApplicationArgs 0
    match main_get_implicit_key_arc4_uint_route@5 main_get_implicit_key_arc4_string_route@6 main_get_implicit_key_arc4_byte_route@7 main_get_implicit_key_arc4_bool_route@8 main_get_implicit_key_arc4_address_route@9 main_get_implicit_key_arc4_uint128_route@10 main_get_implicit_key_arc4_dynamic_bytes_route@11 main_get_implicit_key_tuple_route@12 main_get_arc4_uint_route@13 main_get_arc4_string_route@14 main_get_arc4_byte_route@15 main_get_arc4_bool_route@16 main_get_arc4_address_route@17 main_get_arc4_uint128_route@18 main_get_arc4_dynamic_bytes_route@19 main_set_implicit_key_arc4_uint_route@20 main_set_implicit_key_arc4_string_route@21 main_set_implicit_key_arc4_byte_route@22 main_set_implicit_key_arc4_bool_route@23 main_set_implicit_key_arc4_address_route@24 main_set_implicit_key_arc4_uint128_route@25 main_set_implicit_key_arc4_dynamic_bytes_route@26 main_set_implicit_key_tuple_route@27 main_set_arc4_uint_route@28 main_set_arc4_string_route@29 main_set_arc4_byte_route@30 main_set_arc4_bool_route@31 main_set_arc4_address_route@32 main_set_arc4_uint128_route@33 main_set_arc4_dynamic_bytes_route@34

main_after_if_else@37:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    intc_1 // 0
    return

main_set_arc4_dynamic_bytes_route@34:
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    callsub set_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_arc4_uint128_route@33:
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    callsub set_arc4_uint128
    intc_0 // 1
    return

main_set_arc4_address_route@32:
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    callsub set_arc4_address
    intc_0 // 1
    return

main_set_arc4_bool_route@31:
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    callsub set_arc4_bool
    intc_0 // 1
    return

main_set_arc4_byte_route@30:
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    callsub set_arc4_byte
    intc_0 // 1
    return

main_set_arc4_string_route@29:
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    callsub set_arc4_string
    intc_0 // 1
    return

main_set_arc4_uint_route@28:
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    callsub set_arc4_uint
    intc_0 // 1
    return

main_set_implicit_key_tuple_route@27:
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    callsub set_implicit_key_tuple
    intc_0 // 1
    return

main_set_implicit_key_arc4_dynamic_bytes_route@26:
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint128_route@25:
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint128
    intc_0 // 1
    return

main_set_implicit_key_arc4_address_route@24:
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_address
    intc_0 // 1
    return

main_set_implicit_key_arc4_bool_route@23:
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_bool
    intc_0 // 1
    return

main_set_implicit_key_arc4_byte_route@22:
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_byte
    intc_0 // 1
    return

main_set_implicit_key_arc4_string_route@21:
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_string
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint_route@20:
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint
    intc_0 // 1
    return

main_get_arc4_dynamic_bytes_route@19:
    // tests/artifacts/StateOps/contract.py:596
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint128_route@18:
    // tests/artifacts/StateOps/contract.py:592
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_address_route@17:
    // tests/artifacts/StateOps/contract.py:588
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_bool_route@16:
    // tests/artifacts/StateOps/contract.py:584
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_byte_route@15:
    // tests/artifacts/StateOps/contract.py:580
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_string_route@14:
    // tests/artifacts/StateOps/contract.py:576
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint_route@13:
    // tests/artifacts/StateOps/contract.py:571-572
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_tuple_route@12:
    // tests/artifacts/StateOps/contract.py:567
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    bytec 21 // 0x000b
    concat
    bytec_1 // 0x00
    intc_1 // 0
    uncover 4
    setbit
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@11:
    // tests/artifacts/StateOps/contract.py:563
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint128_route@10:
    // tests/artifacts/StateOps/contract.py:559
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_address_route@9:
    // tests/artifacts/StateOps/contract.py:555
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_bool_route@8:
    // tests/artifacts/StateOps/contract.py:551
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_byte_route@7:
    // tests/artifacts/StateOps/contract.py:547
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_string_route@6:
    // tests/artifacts/StateOps/contract.py:543
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint_route@5:
    // tests/artifacts/StateOps/contract.py:538-539
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@35:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@37
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint() -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_uint.value
    intc_1 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_string() -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:545
    // return self.implicit_key_arc4_string.value
    intc_1 // 0
    bytec_3 // "implicit_key_arc4_string"
    app_global_get_ex
    assert // check self.implicit_key_arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_byte() -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:549
    // return self.implicit_key_arc4_byte.value
    intc_1 // 0
    bytec 4 // "implicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.implicit_key_arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_bool() -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:553
    // return self.implicit_key_arc4_bool.value
    intc_1 // 0
    bytec 5 // "implicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.implicit_key_arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_address() -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:557
    // return self.implicit_key_arc4_address.value
    intc_1 // 0
    bytec 6 // "implicit_key_arc4_address"
    app_global_get_ex
    assert // check self.implicit_key_arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint128() -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:561
    // return self.implicit_key_arc4_uint128.value
    intc_1 // 0
    bytec 7 // "implicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_dynamic_bytes() -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:565
    // return self.implicit_key_arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_tuple() -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:569
    // return self.implicit_key_tuple.value
    intc_1 // 0
    bytec 9 // "implicit_key_tuple"
    app_global_get_ex
    assert // check self.implicit_key_tuple exists
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint() -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:574
    // return self.arc4_uint.value
    intc_1 // 0
    bytec 10 // "explicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_string() -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:578
    // return self.arc4_string.value
    intc_1 // 0
    bytec 11 // "explicit_key_arc4_string"
    app_global_get_ex
    assert // check self.arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_byte() -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:582
    // return self.arc4_byte.value
    intc_1 // 0
    bytec 12 // "explicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_bool() -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:586
    // return self.arc4_bool.value
    intc_1 // 0
    bytec 13 // "explicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_address() -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:590
    // return self.arc4_address.value
    intc_1 // 0
    bytec 14 // "explicit_key_arc4_address"
    app_global_get_ex
    assert // check self.arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint128() -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:594
    // return self.arc4_uint128.value
    intc_1 // 0
    bytec 15 // "explicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_dynamic_bytes() -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:598
    // return self.arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint(value: bytes) -> void:
set_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:600-602
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_uint.value = value
    bytec_2 // "implicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_string(value: bytes) -> void:
set_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:605-606
    // @arc4.abimethod()
    // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_string.value = value
    bytec_3 // "implicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_byte(value: bytes) -> void:
set_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:609-610
    // @arc4.abimethod()
    // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_byte.value = value
    bytec 4 // "implicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_bool(value: bytes) -> void:
set_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:613-614
    // @arc4.abimethod()
    // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_bool.value = value
    bytec 5 // "implicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_address(value: bytes) -> void:
set_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:617-618
    // @arc4.abimethod()
    // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_address.value = value
    bytec 6 // "implicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint128(value: bytes) -> void:
set_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:621-622
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_uint128.value = value
    bytec 7 // "implicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_dynamic_bytes(value: bytes) -> void:
set_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:625-626
    // @arc4.abimethod()
    // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:627
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_tuple(value.0: uint64, value.1: bytes, value.2: uint64) -> void:
set_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:629-630
    // @arc4.abimethod()
    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:631
    // self.implicit_key_tuple.value = value
    frame_dig -3
    itob
    frame_dig -2
    len
    itob
    extract 6 2
    frame_dig -2
    concat
    swap
    bytec 21 // 0x000b
    concat
    bytec_1 // 0x00
    intc_1 // 0
    frame_dig -1
    setbit
    concat
    swap
    concat
    bytec 9 // "implicit_key_tuple"
    swap
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:633-635
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    // def set_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_uint.value = value
    bytec 10 // "explicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_string(value: bytes) -> void:
set_arc4_string:
    // tests/artifacts/StateOps/contract.py:638-639
    // @arc4.abimethod()
    // def set_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_string.value = value
    bytec 11 // "explicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_byte(value: bytes) -> void:
set_arc4_byte:
    // tests/artifacts/StateOps/contract.py:642-643
    // @arc4.abimethod()
    // def set_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_byte.value = value
    bytec 12 // "explicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_bool(value: bytes) -> void:
set_arc4_bool:
    // tests/artifacts/StateOps/contract.py:646-647
    // @arc4.abimethod()
    // def set_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_bool.value = value
    bytec 13 // "explicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_address(value: bytes) -> void:
set_arc4_address:
    // tests/artifacts/StateOps/contract.py:650-651
    // @arc4.abimethod()
    // def set_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_address.value = value
    bytec 14 // "explicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint128(value: bytes) -> void:
set_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:654-655
    // @arc4.abimethod()
    // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:656
    // self.arc4_uint128.value = value
    bytec 15 // "explicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_dynamic_bytes(value: bytes) -> void:
set_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:658-659
    // @arc4.abimethod()
    // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:660
    // self.arc4_dynamic_bytes.value = value.copy()
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/StateOps/data/GlobalStateContract.arc56.json b/tests/artifacts/StateOps/data/GlobalStateContract.arc56.json
index 5c530513..8704eb9f 100644
--- a/tests/artifacts/StateOps/data/GlobalStateContract.arc56.json
+++ b/tests/artifacts/StateOps/data/GlobalStateContract.arc56.json
@@ -680,34 +680,34 @@
                         841,
                         856,
                         871,
-                        915,
-                        930,
-                        945,
-                        960,
-                        975,
-                        990,
-                        1005,
-                        1020,
-                        1036,
-                        1052,
-                        1068,
-                        1084,
-                        1100,
-                        1116,
-                        1132,
-                        1175,
-                        1191,
-                        1207,
-                        1223,
-                        1239,
-                        1255,
-                        1271
+                        908,
+                        923,
+                        938,
+                        953,
+                        968,
+                        983,
+                        998,
+                        1013,
+                        1029,
+                        1045,
+                        1061,
+                        1077,
+                        1093,
+                        1109,
+                        1125,
+                        1166,
+                        1182,
+                        1198,
+                        1214,
+                        1230,
+                        1246,
+                        1262
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        1292
+                        1283
                     ],
                     "errorMessage": "can only call when creating"
                 },
@@ -721,118 +721,118 @@
                         844,
                         859,
                         874,
-                        918,
-                        933,
-                        948,
-                        963,
-                        978,
-                        993,
-                        1008,
-                        1023,
-                        1039,
-                        1055,
-                        1071,
-                        1087,
-                        1103,
-                        1119,
-                        1135,
-                        1178,
-                        1194,
-                        1210,
-                        1226,
-                        1242,
-                        1258,
-                        1274
+                        911,
+                        926,
+                        941,
+                        956,
+                        971,
+                        986,
+                        1001,
+                        1016,
+                        1032,
+                        1048,
+                        1064,
+                        1080,
+                        1096,
+                        1112,
+                        1128,
+                        1169,
+                        1185,
+                        1201,
+                        1217,
+                        1233,
+                        1249,
+                        1265
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        1398
+                        1382
                     ],
                     "errorMessage": "check self.arc4_address exists"
                 },
                 {
                     "pc": [
-                        1392
+                        1376
                     ],
                     "errorMessage": "check self.arc4_bool exists"
                 },
                 {
                     "pc": [
-                        1386
+                        1370
                     ],
                     "errorMessage": "check self.arc4_byte exists"
                 },
                 {
                     "pc": [
-                        1410
+                        1394
                     ],
                     "errorMessage": "check self.arc4_dynamic_bytes exists"
                 },
                 {
                     "pc": [
-                        1380
+                        1364
                     ],
                     "errorMessage": "check self.arc4_string exists"
                 },
                 {
                     "pc": [
-                        1374
+                        1358
                     ],
                     "errorMessage": "check self.arc4_uint exists"
                 },
                 {
                     "pc": [
-                        1404
+                        1388
                     ],
                     "errorMessage": "check self.arc4_uint128 exists"
                 },
                 {
                     "pc": [
-                        1321
+                        1312
                     ],
                     "errorMessage": "check self.implicit_key_arc4_address exists"
                 },
                 {
                     "pc": [
-                        1315
+                        1306
                     ],
                     "errorMessage": "check self.implicit_key_arc4_bool exists"
                 },
                 {
                     "pc": [
-                        1309
+                        1300
                     ],
                     "errorMessage": "check self.implicit_key_arc4_byte exists"
                 },
                 {
                     "pc": [
-                        1333
+                        1324
                     ],
                     "errorMessage": "check self.implicit_key_arc4_dynamic_bytes exists"
                 },
                 {
                     "pc": [
-                        1303
+                        1294
                     ],
                     "errorMessage": "check self.implicit_key_arc4_string exists"
                 },
                 {
                     "pc": [
-                        1298
+                        1289
                     ],
                     "errorMessage": "check self.implicit_key_arc4_uint exists"
                 },
                 {
                     "pc": [
-                        1327
+                        1318
                     ],
                     "errorMessage": "check self.implicit_key_arc4_uint128 exists"
                 },
                 {
                     "pc": [
-                        1339
+                        1330
                     ],
                     "errorMessage": "check self.implicit_key_tuple exists"
                 }
@@ -845,19 +845,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.GlobalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0 8 80
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" "implicit_key_arc4_string" "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" "implicit_key_arc4_dynamic_bytes" "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes" 0x0000000000000539 0x000548656c6c6f 0x00000010000000000000000000000000 0x000d64796e616d6963206279746573 0x000b
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateOps/contract.py:515-516
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    bytec_2 // "implicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec_3 // "implicit_key_arc4_string"
    bytec 18 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:518
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    bytec 4 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    bytec 5 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:520
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    bytec 6 // "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:521
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    bytec 7 // "implicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    bytec 20 // 0x000d64796e616d6963206279746573
    app_global_put
    // tests/artifacts/StateOps/contract.py:523
    // self.implicit_key_tuple = GlobalState((UInt64(10), Bytes(b"test"), False))
    bytec 9 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_global_put
    // tests/artifacts/StateOps/contract.py:525-526
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    bytec 10 // "explicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    bytec 11 // "explicit_key_arc4_string"
    bytec 18 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:528
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    bytec 12 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    bytec 13 // "explicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:531
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    bytec 14 // "explicit_key_arc4_address"
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:530-532
    // self.arc4_address = GlobalState(
    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    // )
    app_global_put
    // tests/artifacts/StateOps/contract.py:533
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    bytec 15 // "explicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:535
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    bytec 20 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:534-536
    // self.arc4_dynamic_bytes = GlobalState(
    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    // )
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@35
    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x166c6afd 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 0x461afc6d 0x048116ea 0x30e34a93 0xd2e646ef 0xe674a270 0xa87e540d 0x720a3ca0 0x257708f7 // method "get_implicit_key_arc4_uint()uint64", method "get_implicit_key_arc4_string()string", method "get_implicit_key_arc4_byte()byte", method "get_implicit_key_arc4_bool()bool", method "get_implicit_key_arc4_address()address", method "get_implicit_key_arc4_uint128()uint128", method "get_implicit_key_arc4_dynamic_bytes()byte[]", method "get_implicit_key_tuple()(uint64,byte[],bool)", method "get_arc4_uint()uint64", method "get_arc4_string()string", method "get_arc4_byte()byte", method "get_arc4_bool()bool", method "get_arc4_address()address", method "get_arc4_uint128()uint128", method "get_arc4_dynamic_bytes()byte[]", method "set_implicit_key_arc4_uint(uint64)void", method "set_implicit_key_arc4_string(string)void", method "set_implicit_key_arc4_byte(byte)void", method "set_implicit_key_arc4_bool(bool)void", method "set_implicit_key_arc4_address(address)void", method "set_implicit_key_arc4_uint128(uint128)void", method "set_implicit_key_arc4_dynamic_bytes(byte[])void", method "set_implicit_key_tuple((uint64,byte[],bool))void", method "set_arc4_uint(uint64)void", method "set_arc4_string(string)void", method "set_arc4_byte(byte)void", method "set_arc4_bool(bool)void", method "set_arc4_address(address)void", method "set_arc4_uint128(uint128)void", method "set_arc4_dynamic_bytes(byte[])void"
    txna ApplicationArgs 0
    match main_get_implicit_key_arc4_uint_route@5 main_get_implicit_key_arc4_string_route@6 main_get_implicit_key_arc4_byte_route@7 main_get_implicit_key_arc4_bool_route@8 main_get_implicit_key_arc4_address_route@9 main_get_implicit_key_arc4_uint128_route@10 main_get_implicit_key_arc4_dynamic_bytes_route@11 main_get_implicit_key_tuple_route@12 main_get_arc4_uint_route@13 main_get_arc4_string_route@14 main_get_arc4_byte_route@15 main_get_arc4_bool_route@16 main_get_arc4_address_route@17 main_get_arc4_uint128_route@18 main_get_arc4_dynamic_bytes_route@19 main_set_implicit_key_arc4_uint_route@20 main_set_implicit_key_arc4_string_route@21 main_set_implicit_key_arc4_byte_route@22 main_set_implicit_key_arc4_bool_route@23 main_set_implicit_key_arc4_address_route@24 main_set_implicit_key_arc4_uint128_route@25 main_set_implicit_key_arc4_dynamic_bytes_route@26 main_set_implicit_key_tuple_route@27 main_set_arc4_uint_route@28 main_set_arc4_string_route@29 main_set_arc4_byte_route@30 main_set_arc4_bool_route@31 main_set_arc4_address_route@32 main_set_arc4_uint128_route@33 main_set_arc4_dynamic_bytes_route@34

main_after_if_else@37:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    intc_1 // 0
    return

main_set_arc4_dynamic_bytes_route@34:
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    callsub set_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_arc4_uint128_route@33:
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    callsub set_arc4_uint128
    intc_0 // 1
    return

main_set_arc4_address_route@32:
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    callsub set_arc4_address
    intc_0 // 1
    return

main_set_arc4_bool_route@31:
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    callsub set_arc4_bool
    intc_0 // 1
    return

main_set_arc4_byte_route@30:
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    callsub set_arc4_byte
    intc_0 // 1
    return

main_set_arc4_string_route@29:
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    callsub set_arc4_string
    intc_0 // 1
    return

main_set_arc4_uint_route@28:
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    callsub set_arc4_uint
    intc_0 // 1
    return

main_set_implicit_key_tuple_route@27:
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    intc_1 // 0
    getbit
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    callsub set_implicit_key_tuple
    intc_0 // 1
    return

main_set_implicit_key_arc4_dynamic_bytes_route@26:
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint128_route@25:
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint128
    intc_0 // 1
    return

main_set_implicit_key_arc4_address_route@24:
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_address
    intc_0 // 1
    return

main_set_implicit_key_arc4_bool_route@23:
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_bool
    intc_0 // 1
    return

main_set_implicit_key_arc4_byte_route@22:
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_byte
    intc_0 // 1
    return

main_set_implicit_key_arc4_string_route@21:
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_string
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint_route@20:
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint
    intc_0 // 1
    return

main_get_arc4_dynamic_bytes_route@19:
    // tests/artifacts/StateOps/contract.py:596
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint128_route@18:
    // tests/artifacts/StateOps/contract.py:592
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_address_route@17:
    // tests/artifacts/StateOps/contract.py:588
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_bool_route@16:
    // tests/artifacts/StateOps/contract.py:584
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_byte_route@15:
    // tests/artifacts/StateOps/contract.py:580
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_string_route@14:
    // tests/artifacts/StateOps/contract.py:576
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint_route@13:
    // tests/artifacts/StateOps/contract.py:571-572
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_tuple_route@12:
    // tests/artifacts/StateOps/contract.py:567
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    bytec_1 // 0x00
    intc_1 // 0
    uncover 4
    setbit
    uncover 2
    bytec 21 // 0x000b
    concat
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@11:
    // tests/artifacts/StateOps/contract.py:563
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint128_route@10:
    // tests/artifacts/StateOps/contract.py:559
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_address_route@9:
    // tests/artifacts/StateOps/contract.py:555
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_bool_route@8:
    // tests/artifacts/StateOps/contract.py:551
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_byte_route@7:
    // tests/artifacts/StateOps/contract.py:547
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_string_route@6:
    // tests/artifacts/StateOps/contract.py:543
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint_route@5:
    // tests/artifacts/StateOps/contract.py:538-539
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@35:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@37
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint() -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_uint.value
    intc_1 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_string() -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:545
    // return self.implicit_key_arc4_string.value
    intc_1 // 0
    bytec_3 // "implicit_key_arc4_string"
    app_global_get_ex
    assert // check self.implicit_key_arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_byte() -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:549
    // return self.implicit_key_arc4_byte.value
    intc_1 // 0
    bytec 4 // "implicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.implicit_key_arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_bool() -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:553
    // return self.implicit_key_arc4_bool.value
    intc_1 // 0
    bytec 5 // "implicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.implicit_key_arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_address() -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:557
    // return self.implicit_key_arc4_address.value
    intc_1 // 0
    bytec 6 // "implicit_key_arc4_address"
    app_global_get_ex
    assert // check self.implicit_key_arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint128() -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:561
    // return self.implicit_key_arc4_uint128.value
    intc_1 // 0
    bytec 7 // "implicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_dynamic_bytes() -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:565
    // return self.implicit_key_arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_tuple() -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:569
    // return self.implicit_key_tuple.value
    intc_1 // 0
    bytec 9 // "implicit_key_tuple"
    app_global_get_ex
    assert // check self.implicit_key_tuple exists
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    intc_1 // 0
    getbit
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint() -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:574
    // return self.arc4_uint.value
    intc_1 // 0
    bytec 10 // "explicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_string() -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:578
    // return self.arc4_string.value
    intc_1 // 0
    bytec 11 // "explicit_key_arc4_string"
    app_global_get_ex
    assert // check self.arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_byte() -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:582
    // return self.arc4_byte.value
    intc_1 // 0
    bytec 12 // "explicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_bool() -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:586
    // return self.arc4_bool.value
    intc_1 // 0
    bytec 13 // "explicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_address() -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:590
    // return self.arc4_address.value
    intc_1 // 0
    bytec 14 // "explicit_key_arc4_address"
    app_global_get_ex
    assert // check self.arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint128() -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:594
    // return self.arc4_uint128.value
    intc_1 // 0
    bytec 15 // "explicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_dynamic_bytes() -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:598
    // return self.arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint(value: bytes) -> void:
set_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:600-602
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_uint.value = value
    bytec_2 // "implicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_string(value: bytes) -> void:
set_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:605-606
    // @arc4.abimethod()
    // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_string.value = value
    bytec_3 // "implicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_byte(value: bytes) -> void:
set_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:609-610
    // @arc4.abimethod()
    // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_byte.value = value
    bytec 4 // "implicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_bool(value: bytes) -> void:
set_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:613-614
    // @arc4.abimethod()
    // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_bool.value = value
    bytec 5 // "implicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_address(value: bytes) -> void:
set_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:617-618
    // @arc4.abimethod()
    // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_address.value = value
    bytec 6 // "implicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint128(value: bytes) -> void:
set_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:621-622
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_uint128.value = value
    bytec 7 // "implicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_dynamic_bytes(value: bytes) -> void:
set_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:625-626
    // @arc4.abimethod()
    // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:627
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_tuple(value.0: uint64, value.1: bytes, value.2: uint64) -> void:
set_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:629-630
    // @arc4.abimethod()
    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:630
    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
    frame_dig -3
    itob
    frame_dig -2
    len
    itob
    extract 6 2
    frame_dig -2
    concat
    bytec_1 // 0x00
    intc_1 // 0
    frame_dig -1
    setbit
    // tests/artifacts/StateOps/contract.py:631
    // self.implicit_key_tuple.value = value
    uncover 2
    bytec 21 // 0x000b
    concat
    swap
    concat
    swap
    concat
    bytec 9 // "implicit_key_tuple"
    swap
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:633-635
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    // def set_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_uint.value = value
    bytec 10 // "explicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_string(value: bytes) -> void:
set_arc4_string:
    // tests/artifacts/StateOps/contract.py:638-639
    // @arc4.abimethod()
    // def set_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_string.value = value
    bytec 11 // "explicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_byte(value: bytes) -> void:
set_arc4_byte:
    // tests/artifacts/StateOps/contract.py:642-643
    // @arc4.abimethod()
    // def set_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_byte.value = value
    bytec 12 // "explicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_bool(value: bytes) -> void:
set_arc4_bool:
    // tests/artifacts/StateOps/contract.py:646-647
    // @arc4.abimethod()
    // def set_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_bool.value = value
    bytec 13 // "explicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_address(value: bytes) -> void:
set_arc4_address:
    // tests/artifacts/StateOps/contract.py:650-651
    // @arc4.abimethod()
    // def set_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_address.value = value
    bytec 14 // "explicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint128(value: bytes) -> void:
set_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:654-655
    // @arc4.abimethod()
    // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:656
    // self.arc4_uint128.value = value
    bytec 15 // "explicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_dynamic_bytes(value: bytes) -> void:
set_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:658-659
    // @arc4.abimethod()
    // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:660
    // self.arc4_dynamic_bytes.value = value.copy()
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.GlobalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0 8 80
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" "implicit_key_arc4_string" "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" "implicit_key_arc4_dynamic_bytes" "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes" 0x0000000000000539 0x000548656c6c6f 0x00000010000000000000000000000000 0x000d64796e616d6963206279746573 0x000b
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateOps/contract.py:515-516
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    bytec_2 // "implicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec_3 // "implicit_key_arc4_string"
    bytec 18 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:518
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    bytec 4 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    bytec 5 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:520
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    bytec 6 // "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:521
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    bytec 7 // "implicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    bytec 20 // 0x000d64796e616d6963206279746573
    app_global_put
    // tests/artifacts/StateOps/contract.py:523
    // self.implicit_key_tuple = GlobalState((UInt64(10), Bytes(b"test"), False))
    bytec 9 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_global_put
    // tests/artifacts/StateOps/contract.py:525-526
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    bytec 10 // "explicit_key_arc4_uint"
    bytec 17 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    bytec 11 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:517
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec 18 // 0x000548656c6c6f
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    app_global_put
    // tests/artifacts/StateOps/contract.py:528
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    bytec 12 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    bytec 13 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    pushbytes 0x80
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    app_global_put
    // tests/artifacts/StateOps/contract.py:531
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    bytec 14 // "explicit_key_arc4_address"
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:530-532
    // self.arc4_address = GlobalState(
    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    // )
    app_global_put
    // tests/artifacts/StateOps/contract.py:533
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    bytec 15 // "explicit_key_arc4_uint128"
    bytec 19 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:535
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 20 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:534-536
    // self.arc4_dynamic_bytes = GlobalState(
    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    // )
    app_global_put

main_after_if_else@2:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@35
    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x166c6afd 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 0x461afc6d 0x048116ea 0x30e34a93 0xd2e646ef 0xe674a270 0xa87e540d 0x720a3ca0 0x257708f7 // method "get_implicit_key_arc4_uint()uint64", method "get_implicit_key_arc4_string()string", method "get_implicit_key_arc4_byte()byte", method "get_implicit_key_arc4_bool()bool", method "get_implicit_key_arc4_address()address", method "get_implicit_key_arc4_uint128()uint128", method "get_implicit_key_arc4_dynamic_bytes()byte[]", method "get_implicit_key_tuple()(uint64,byte[],bool)", method "get_arc4_uint()uint64", method "get_arc4_string()string", method "get_arc4_byte()byte", method "get_arc4_bool()bool", method "get_arc4_address()address", method "get_arc4_uint128()uint128", method "get_arc4_dynamic_bytes()byte[]", method "set_implicit_key_arc4_uint(uint64)void", method "set_implicit_key_arc4_string(string)void", method "set_implicit_key_arc4_byte(byte)void", method "set_implicit_key_arc4_bool(bool)void", method "set_implicit_key_arc4_address(address)void", method "set_implicit_key_arc4_uint128(uint128)void", method "set_implicit_key_arc4_dynamic_bytes(byte[])void", method "set_implicit_key_tuple((uint64,byte[],bool))void", method "set_arc4_uint(uint64)void", method "set_arc4_string(string)void", method "set_arc4_byte(byte)void", method "set_arc4_bool(bool)void", method "set_arc4_address(address)void", method "set_arc4_uint128(uint128)void", method "set_arc4_dynamic_bytes(byte[])void"
    txna ApplicationArgs 0
    match main_get_implicit_key_arc4_uint_route@5 main_get_implicit_key_arc4_string_route@6 main_get_implicit_key_arc4_byte_route@7 main_get_implicit_key_arc4_bool_route@8 main_get_implicit_key_arc4_address_route@9 main_get_implicit_key_arc4_uint128_route@10 main_get_implicit_key_arc4_dynamic_bytes_route@11 main_get_implicit_key_tuple_route@12 main_get_arc4_uint_route@13 main_get_arc4_string_route@14 main_get_arc4_byte_route@15 main_get_arc4_bool_route@16 main_get_arc4_address_route@17 main_get_arc4_uint128_route@18 main_get_arc4_dynamic_bytes_route@19 main_set_implicit_key_arc4_uint_route@20 main_set_implicit_key_arc4_string_route@21 main_set_implicit_key_arc4_byte_route@22 main_set_implicit_key_arc4_bool_route@23 main_set_implicit_key_arc4_address_route@24 main_set_implicit_key_arc4_uint128_route@25 main_set_implicit_key_arc4_dynamic_bytes_route@26 main_set_implicit_key_tuple_route@27 main_set_arc4_uint_route@28 main_set_arc4_string_route@29 main_set_arc4_byte_route@30 main_set_arc4_bool_route@31 main_set_arc4_address_route@32 main_set_arc4_uint128_route@33 main_set_arc4_dynamic_bytes_route@34

main_after_if_else@37:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    intc_1 // 0
    return

main_set_arc4_dynamic_bytes_route@34:
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:658
    // @arc4.abimethod()
    callsub set_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_arc4_uint128_route@33:
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:654
    // @arc4.abimethod()
    callsub set_arc4_uint128
    intc_0 // 1
    return

main_set_arc4_address_route@32:
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    callsub set_arc4_address
    intc_0 // 1
    return

main_set_arc4_bool_route@31:
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    callsub set_arc4_bool
    intc_0 // 1
    return

main_set_arc4_byte_route@30:
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    callsub set_arc4_byte
    intc_0 // 1
    return

main_set_arc4_string_route@29:
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    callsub set_arc4_string
    intc_0 // 1
    return

main_set_arc4_uint_route@28:
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:633-634
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    callsub set_arc4_uint
    intc_0 // 1
    return

main_set_implicit_key_tuple_route@27:
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    // tests/artifacts/StateOps/contract.py:629
    // @arc4.abimethod()
    callsub set_implicit_key_tuple
    intc_0 // 1
    return

main_set_implicit_key_arc4_dynamic_bytes_route@26:
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:625
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint128_route@25:
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint128
    intc_0 // 1
    return

main_set_implicit_key_arc4_address_route@24:
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_address
    intc_0 // 1
    return

main_set_implicit_key_arc4_bool_route@23:
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_bool
    intc_0 // 1
    return

main_set_implicit_key_arc4_byte_route@22:
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_byte
    intc_0 // 1
    return

main_set_implicit_key_arc4_string_route@21:
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_string
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint_route@20:
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:600-601
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint
    intc_0 // 1
    return

main_get_arc4_dynamic_bytes_route@19:
    // tests/artifacts/StateOps/contract.py:596
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint128_route@18:
    // tests/artifacts/StateOps/contract.py:592
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_address_route@17:
    // tests/artifacts/StateOps/contract.py:588
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_bool_route@16:
    // tests/artifacts/StateOps/contract.py:584
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_byte_route@15:
    // tests/artifacts/StateOps/contract.py:580
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_string_route@14:
    // tests/artifacts/StateOps/contract.py:576
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint_route@13:
    // tests/artifacts/StateOps/contract.py:571-572
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_tuple_route@12:
    // tests/artifacts/StateOps/contract.py:567
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    bytec 21 // 0x000b
    concat
    bytec_1 // 0x00
    intc_1 // 0
    uncover 4
    setbit
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@11:
    // tests/artifacts/StateOps/contract.py:563
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint128_route@10:
    // tests/artifacts/StateOps/contract.py:559
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_address_route@9:
    // tests/artifacts/StateOps/contract.py:555
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_bool_route@8:
    // tests/artifacts/StateOps/contract.py:551
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_byte_route@7:
    // tests/artifacts/StateOps/contract.py:547
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_string_route@6:
    // tests/artifacts/StateOps/contract.py:543
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint_route@5:
    // tests/artifacts/StateOps/contract.py:538-539
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@35:
    // tests/artifacts/StateOps/contract.py:513
    // class GlobalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@37
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint() -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_uint.value
    intc_1 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_string() -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:545
    // return self.implicit_key_arc4_string.value
    intc_1 // 0
    bytec_3 // "implicit_key_arc4_string"
    app_global_get_ex
    assert // check self.implicit_key_arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_byte() -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:549
    // return self.implicit_key_arc4_byte.value
    intc_1 // 0
    bytec 4 // "implicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.implicit_key_arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_bool() -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:553
    // return self.implicit_key_arc4_bool.value
    intc_1 // 0
    bytec 5 // "implicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.implicit_key_arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_address() -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:557
    // return self.implicit_key_arc4_address.value
    intc_1 // 0
    bytec 6 // "implicit_key_arc4_address"
    app_global_get_ex
    assert // check self.implicit_key_arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint128() -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:561
    // return self.implicit_key_arc4_uint128.value
    intc_1 // 0
    bytec 7 // "implicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.implicit_key_arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_dynamic_bytes() -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:565
    // return self.implicit_key_arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_tuple() -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:569
    // return self.implicit_key_tuple.value
    intc_1 // 0
    bytec 9 // "implicit_key_tuple"
    app_global_get_ex
    assert // check self.implicit_key_tuple exists
    dup
    intc_1 // 0
    extract_uint64
    dig 1
    intc_2 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    intc_3 // 80
    getbit
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint() -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:574
    // return self.arc4_uint.value
    intc_1 // 0
    bytec 10 // "explicit_key_arc4_uint"
    app_global_get_ex
    assert // check self.arc4_uint exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_string() -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:578
    // return self.arc4_string.value
    intc_1 // 0
    bytec 11 // "explicit_key_arc4_string"
    app_global_get_ex
    assert // check self.arc4_string exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_byte() -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:582
    // return self.arc4_byte.value
    intc_1 // 0
    bytec 12 // "explicit_key_arc4_byte"
    app_global_get_ex
    assert // check self.arc4_byte exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_bool() -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:586
    // return self.arc4_bool.value
    intc_1 // 0
    bytec 13 // "explicit_key_arc4_bool"
    app_global_get_ex
    assert // check self.arc4_bool exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_address() -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:590
    // return self.arc4_address.value
    intc_1 // 0
    bytec 14 // "explicit_key_arc4_address"
    app_global_get_ex
    assert // check self.arc4_address exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint128() -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:594
    // return self.arc4_uint128.value
    intc_1 // 0
    bytec 15 // "explicit_key_arc4_uint128"
    app_global_get_ex
    assert // check self.arc4_uint128 exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_dynamic_bytes() -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:598
    // return self.arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    app_global_get_ex
    assert // check self.arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint(value: bytes) -> void:
set_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:600-602
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_uint.value = value
    bytec_2 // "implicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_string(value: bytes) -> void:
set_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:605-606
    // @arc4.abimethod()
    // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_string.value = value
    bytec_3 // "implicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_byte(value: bytes) -> void:
set_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:609-610
    // @arc4.abimethod()
    // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_byte.value = value
    bytec 4 // "implicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_bool(value: bytes) -> void:
set_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:613-614
    // @arc4.abimethod()
    // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_bool.value = value
    bytec 5 // "implicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_address(value: bytes) -> void:
set_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:617-618
    // @arc4.abimethod()
    // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_address.value = value
    bytec 6 // "implicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint128(value: bytes) -> void:
set_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:621-622
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_uint128.value = value
    bytec 7 // "implicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_dynamic_bytes(value: bytes) -> void:
set_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:625-626
    // @arc4.abimethod()
    // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:627
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    bytec 8 // "implicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_tuple(value.0: uint64, value.1: bytes, value.2: uint64) -> void:
set_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:629-630
    // @arc4.abimethod()
    // def set_implicit_key_tuple(self, value: tuple[UInt64, Bytes, bool]) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:631
    // self.implicit_key_tuple.value = value
    frame_dig -3
    itob
    frame_dig -2
    len
    itob
    extract 6 2
    frame_dig -2
    concat
    swap
    bytec 21 // 0x000b
    concat
    bytec_1 // 0x00
    intc_1 // 0
    frame_dig -1
    setbit
    concat
    swap
    concat
    bytec 9 // "implicit_key_tuple"
    swap
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:633-635
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    // def set_arc4_uint(self, value: arc4.UInt64) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_uint.value = value
    bytec 10 // "explicit_key_arc4_uint"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_string(value: bytes) -> void:
set_arc4_string:
    // tests/artifacts/StateOps/contract.py:638-639
    // @arc4.abimethod()
    // def set_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_string.value = value
    bytec 11 // "explicit_key_arc4_string"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_byte(value: bytes) -> void:
set_arc4_byte:
    // tests/artifacts/StateOps/contract.py:642-643
    // @arc4.abimethod()
    // def set_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_byte.value = value
    bytec 12 // "explicit_key_arc4_byte"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_bool(value: bytes) -> void:
set_arc4_bool:
    // tests/artifacts/StateOps/contract.py:646-647
    // @arc4.abimethod()
    // def set_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_bool.value = value
    bytec 13 // "explicit_key_arc4_bool"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_address(value: bytes) -> void:
set_arc4_address:
    // tests/artifacts/StateOps/contract.py:650-651
    // @arc4.abimethod()
    // def set_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_address.value = value
    bytec 14 // "explicit_key_arc4_address"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint128(value: bytes) -> void:
set_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:654-655
    // @arc4.abimethod()
    // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:656
    // self.arc4_uint128.value = value
    bytec 15 // "explicit_key_arc4_uint128"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_dynamic_bytes(value: bytes) -> void:
set_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:658-659
    // @arc4.abimethod()
    // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:660
    // self.arc4_dynamic_bytes.value = value.copy()
    bytec 16 // "explicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "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",
+        "approval": "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",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/ITxnOpsContract.arc56.json b/tests/artifacts/StateOps/data/ITxnOpsContract.arc56.json
index 7724db82..ce2294b2 100644
--- a/tests/artifacts/StateOps/data/ITxnOpsContract.arc56.json
+++ b/tests/artifacts/StateOps/data/ITxnOpsContract.arc56.json
@@ -93,8 +93,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/LocalStateContract.approval.teal b/tests/artifacts/StateOps/data/LocalStateContract.approval.teal
index 28d2aec3..53894767 100644
--- a/tests/artifacts/StateOps/data/LocalStateContract.approval.teal
+++ b/tests/artifacts/StateOps/data/LocalStateContract.approval.teal
@@ -206,14 +206,13 @@ main_get_implicit_key_tuple_route@13:
     extract 6 2
     uncover 3
     concat
+    swap
+    pushbytes 0x000b
+    concat
     bytec_1 // 0x00
     intc_0 // 0
     uncover 4
     setbit
-    uncover 2
-    pushbytes 0x000b
-    concat
-    swap
     concat
     swap
     concat
@@ -482,7 +481,11 @@ opt_in:
     // self.arc4_string[Global.creator_address] = arc4.String("Hello")
     global CreatorAddress
     bytec 15 // "explicit_key_arc4_string"
+    // tests/artifacts/StateOps/contract.py:689
+    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
     bytec 5 // 0x000548656c6c6f
+    // tests/artifacts/StateOps/contract.py:702
+    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
     app_local_put
     // tests/artifacts/StateOps/contract.py:703
     // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
@@ -494,7 +497,11 @@ opt_in:
     // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
     global CreatorAddress
     bytec 17 // "explicit_key_arc4_bool"
+    // tests/artifacts/StateOps/contract.py:691
+    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
     pushbytes 0x80
+    // tests/artifacts/StateOps/contract.py:704
+    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
     app_local_put
     // tests/artifacts/StateOps/contract.py:705
     // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
@@ -512,7 +519,13 @@ opt_in:
     // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
     global CreatorAddress
     bytec 20 // "explicit_key_arc4_dynamic_bytes"
+    // tests/artifacts/StateOps/contract.py:696-698
+    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
+    //     b"dynamic bytes"
+    // )
     bytec 12 // 0x000d64796e616d6963206279746573
+    // tests/artifacts/StateOps/contract.py:707
+    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
     app_local_put
     retsub
 
@@ -658,12 +671,6 @@ get_implicit_key_tuple:
     uncover 2
     pushint 80 // 80
     getbit
-    bytec_1 // 0x00
-    intc_0 // 0
-    uncover 2
-    setbit
-    intc_0 // 0
-    getbit
     retsub
 
 
diff --git a/tests/artifacts/StateOps/data/LocalStateContract.arc32.json b/tests/artifacts/StateOps/data/LocalStateContract.arc32.json
index d4e0325b..0e5eb4c7 100644
--- a/tests/artifacts/StateOps/data/LocalStateContract.arc32.json
+++ b/tests/artifacts/StateOps/data/LocalStateContract.arc32.json
@@ -82,7 +82,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.LocalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" 0x0000000000000539 "implicit_key_arc4_string" 0x000548656c6c6f "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" 0x00000010000000000000000000000000 "implicit_key_arc4_dynamic_bytes" 0x000d64796e616d6963206279746573 "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@21
    pushbytess 0x30c6d58a 0x2284b7af 0x26b45756 0xecf633b0 0x3e531223 0x3ed6799d 0x5296d5ca 0x676a87c2 0x25bd1059 0x999b7f2b 0x70666842 0x6521d49b 0xe07c56cd 0xaa19d2b5 0x971b071f 0xfc0feed9 // method "opt_in()void", method "get_implicit_key_arc4_uint(account)uint64", method "get_implicit_key_arc4_string(account)string", method "get_implicit_key_arc4_byte(account)byte", method "get_implicit_key_arc4_bool(account)bool", method "get_implicit_key_arc4_address(account)address", method "get_implicit_key_arc4_uint128(account)uint128", method "get_implicit_key_arc4_dynamic_bytes(account)byte[]", method "get_implicit_key_tuple(account)(uint64,byte[],bool)", method "get_arc4_uint(account)uint64", method "get_arc4_string(account)string", method "get_arc4_byte(account)byte", method "get_arc4_bool(account)bool", method "get_arc4_address(account)address", method "get_arc4_uint128(account)uint128", method "get_arc4_dynamic_bytes(account)byte[]"
    txna ApplicationArgs 0
    match main_opt_in_route@5 main_get_implicit_key_arc4_uint_route@6 main_get_implicit_key_arc4_string_route@7 main_get_implicit_key_arc4_byte_route@8 main_get_implicit_key_arc4_bool_route@9 main_get_implicit_key_arc4_address_route@10 main_get_implicit_key_arc4_uint128_route@11 main_get_implicit_key_arc4_dynamic_bytes_route@12 main_get_implicit_key_tuple_route@13 main_get_arc4_uint_route@14 main_get_arc4_string_route@15 main_get_arc4_byte_route@16 main_get_arc4_bool_route@17 main_get_arc4_address_route@18 main_get_arc4_uint128_route@19 main_get_arc4_dynamic_bytes_route@20

main_after_if_else@23:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    intc_0 // 0
    return

main_get_arc4_dynamic_bytes_route@20:
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint128_route@19:
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_address_route@18:
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_bool_route@17:
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_byte_route@16:
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_string_route@15:
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint_route@14:
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_tuple_route@13:
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    uncover 2
    pushbytes 0x000b
    concat
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@12:
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint128_route@11:
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_address_route@10:
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_bool_route@9:
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_byte_route@8:
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_string_route@7:
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint_route@6:
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:686
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_1 // OptIn
    ==
    assert // OnCompletion is not OptIn
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main_bare_routing@21:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@23
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:688
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec_2 // "implicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 4 // "implicit_key_arc4_string"
    bytec 5 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:690
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 6 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 7 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:692
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    bytec 8 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:693
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:692-694
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:695
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 9 // "implicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:696
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 12 // 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:699
    // self.implicit_key_tuple[Global.creator_address] = (UInt64(10), Bytes(b"test"), False)
    global CreatorAddress
    bytec 13 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_local_put
    // tests/artifacts/StateOps/contract.py:701
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec 14 // "explicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 15 // "explicit_key_arc4_string"
    bytec 5 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:703
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 16 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 17 // "explicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:705
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    bytec 18 // "explicit_key_arc4_address"
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:706
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 19 // "explicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    bytec 12 // 0x000d64796e616d6963206279746573
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint(a: bytes) -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:709-711
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:712
    // return self.implicit_key_arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_string(a: bytes) -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:714-715
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:716
    // return self.implicit_key_arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 4 // "implicit_key_arc4_string"
    app_local_get_ex
    assert // check self.implicit_key_arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_byte(a: bytes) -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:718-719
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:720
    // return self.implicit_key_arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 6 // "implicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.implicit_key_arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_bool(a: bytes) -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:722-723
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:724
    // return self.implicit_key_arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 7 // "implicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.implicit_key_arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_address(a: bytes) -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:726-727
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:728
    // return self.implicit_key_arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 8 // "implicit_key_arc4_address"
    app_local_get_ex
    assert // check self.implicit_key_arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint128(a: bytes) -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:730-731
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:732
    // return self.implicit_key_arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 9 // "implicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_dynamic_bytes(a: bytes) -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:734-735
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:736
    // return self.implicit_key_arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_tuple(a: bytes) -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:738-739
    // @arc4.abimethod()
    // def get_implicit_key_tuple(self, a: Account) -> tuple[UInt64, Bytes, bool]:
    proto 1 3
    // tests/artifacts/StateOps/contract.py:740
    // return self.implicit_key_tuple[a]
    frame_dig -1
    intc_0 // 0
    bytec 13 // "implicit_key_tuple"
    app_local_get_ex
    assert // check self.implicit_key_tuple exists for account
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 8 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    pushint 80 // 80
    getbit
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint(a: bytes) -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:742-744
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    // def get_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:745
    // return self.arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec 14 // "explicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_string(a: bytes) -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:747-748
    // @arc4.abimethod()
    // def get_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:749
    // return self.arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 15 // "explicit_key_arc4_string"
    app_local_get_ex
    assert // check self.arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_byte(a: bytes) -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:751-752
    // @arc4.abimethod()
    // def get_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:753
    // return self.arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 16 // "explicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_bool(a: bytes) -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:755-756
    // @arc4.abimethod()
    // def get_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:757
    // return self.arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 17 // "explicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_address(a: bytes) -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:759-760
    // @arc4.abimethod()
    // def get_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:761
    // return self.arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 18 // "explicit_key_arc4_address"
    app_local_get_ex
    assert // check self.arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint128(a: bytes) -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:763-764
    // @arc4.abimethod()
    // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:765
    // return self.arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 19 // "explicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_dynamic_bytes(a: bytes) -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:767-768
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:769
    // return self.arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.LocalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" 0x0000000000000539 "implicit_key_arc4_string" 0x000548656c6c6f "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" 0x00000010000000000000000000000000 "implicit_key_arc4_dynamic_bytes" 0x000d64796e616d6963206279746573 "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@21
    pushbytess 0x30c6d58a 0x2284b7af 0x26b45756 0xecf633b0 0x3e531223 0x3ed6799d 0x5296d5ca 0x676a87c2 0x25bd1059 0x999b7f2b 0x70666842 0x6521d49b 0xe07c56cd 0xaa19d2b5 0x971b071f 0xfc0feed9 // method "opt_in()void", method "get_implicit_key_arc4_uint(account)uint64", method "get_implicit_key_arc4_string(account)string", method "get_implicit_key_arc4_byte(account)byte", method "get_implicit_key_arc4_bool(account)bool", method "get_implicit_key_arc4_address(account)address", method "get_implicit_key_arc4_uint128(account)uint128", method "get_implicit_key_arc4_dynamic_bytes(account)byte[]", method "get_implicit_key_tuple(account)(uint64,byte[],bool)", method "get_arc4_uint(account)uint64", method "get_arc4_string(account)string", method "get_arc4_byte(account)byte", method "get_arc4_bool(account)bool", method "get_arc4_address(account)address", method "get_arc4_uint128(account)uint128", method "get_arc4_dynamic_bytes(account)byte[]"
    txna ApplicationArgs 0
    match main_opt_in_route@5 main_get_implicit_key_arc4_uint_route@6 main_get_implicit_key_arc4_string_route@7 main_get_implicit_key_arc4_byte_route@8 main_get_implicit_key_arc4_bool_route@9 main_get_implicit_key_arc4_address_route@10 main_get_implicit_key_arc4_uint128_route@11 main_get_implicit_key_arc4_dynamic_bytes_route@12 main_get_implicit_key_tuple_route@13 main_get_arc4_uint_route@14 main_get_arc4_string_route@15 main_get_arc4_byte_route@16 main_get_arc4_bool_route@17 main_get_arc4_address_route@18 main_get_arc4_uint128_route@19 main_get_arc4_dynamic_bytes_route@20

main_after_if_else@23:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    intc_0 // 0
    return

main_get_arc4_dynamic_bytes_route@20:
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint128_route@19:
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_address_route@18:
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_bool_route@17:
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_byte_route@16:
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_string_route@15:
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint_route@14:
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_tuple_route@13:
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    pushbytes 0x000b
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@12:
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint128_route@11:
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_address_route@10:
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_bool_route@9:
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_byte_route@8:
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_string_route@7:
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint_route@6:
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:686
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_1 // OptIn
    ==
    assert // OnCompletion is not OptIn
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main_bare_routing@21:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@23
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:688
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec_2 // "implicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 4 // "implicit_key_arc4_string"
    bytec 5 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:690
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 6 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 7 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:692
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    bytec 8 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:693
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:692-694
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:695
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 9 // "implicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:696
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 12 // 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:699
    // self.implicit_key_tuple[Global.creator_address] = (UInt64(10), Bytes(b"test"), False)
    global CreatorAddress
    bytec 13 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_local_put
    // tests/artifacts/StateOps/contract.py:701
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec 14 // "explicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 15 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    bytec 5 // 0x000548656c6c6f
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    app_local_put
    // tests/artifacts/StateOps/contract.py:703
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 16 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 17 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    pushbytes 0x80
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    app_local_put
    // tests/artifacts/StateOps/contract.py:705
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    bytec 18 // "explicit_key_arc4_address"
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:706
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 19 // "explicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 12 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint(a: bytes) -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:709-711
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:712
    // return self.implicit_key_arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_string(a: bytes) -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:714-715
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:716
    // return self.implicit_key_arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 4 // "implicit_key_arc4_string"
    app_local_get_ex
    assert // check self.implicit_key_arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_byte(a: bytes) -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:718-719
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:720
    // return self.implicit_key_arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 6 // "implicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.implicit_key_arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_bool(a: bytes) -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:722-723
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:724
    // return self.implicit_key_arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 7 // "implicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.implicit_key_arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_address(a: bytes) -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:726-727
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:728
    // return self.implicit_key_arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 8 // "implicit_key_arc4_address"
    app_local_get_ex
    assert // check self.implicit_key_arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint128(a: bytes) -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:730-731
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:732
    // return self.implicit_key_arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 9 // "implicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_dynamic_bytes(a: bytes) -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:734-735
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:736
    // return self.implicit_key_arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_tuple(a: bytes) -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:738-739
    // @arc4.abimethod()
    // def get_implicit_key_tuple(self, a: Account) -> tuple[UInt64, Bytes, bool]:
    proto 1 3
    // tests/artifacts/StateOps/contract.py:740
    // return self.implicit_key_tuple[a]
    frame_dig -1
    intc_0 // 0
    bytec 13 // "implicit_key_tuple"
    app_local_get_ex
    assert // check self.implicit_key_tuple exists for account
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 8 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    pushint 80 // 80
    getbit
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint(a: bytes) -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:742-744
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    // def get_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:745
    // return self.arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec 14 // "explicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_string(a: bytes) -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:747-748
    // @arc4.abimethod()
    // def get_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:749
    // return self.arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 15 // "explicit_key_arc4_string"
    app_local_get_ex
    assert // check self.arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_byte(a: bytes) -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:751-752
    // @arc4.abimethod()
    // def get_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:753
    // return self.arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 16 // "explicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_bool(a: bytes) -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:755-756
    // @arc4.abimethod()
    // def get_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:757
    // return self.arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 17 // "explicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_address(a: bytes) -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:759-760
    // @arc4.abimethod()
    // def get_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:761
    // return self.arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 18 // "explicit_key_arc4_address"
    app_local_get_ex
    assert // check self.arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint128(a: bytes) -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:763-764
    // @arc4.abimethod()
    // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:765
    // return self.arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 19 // "explicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_dynamic_bytes(a: bytes) -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:767-768
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:769
    // return self.arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/StateOps/data/LocalStateContract.arc56.json b/tests/artifacts/StateOps/data/LocalStateContract.arc56.json
index df4fef9f..b18b128e 100644
--- a/tests/artifacts/StateOps/data/LocalStateContract.arc56.json
+++ b/tests/artifacts/StateOps/data/LocalStateContract.arc56.json
@@ -456,25 +456,25 @@
                         678,
                         700,
                         722,
-                        773,
-                        795,
-                        817,
-                        839,
-                        861,
-                        883,
-                        905
+                        771,
+                        793,
+                        815,
+                        837,
+                        859,
+                        881,
+                        903
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        928
+                        926
                     ],
                     "errorMessage": "OnCompletion is not OptIn"
                 },
                 {
                     "pc": [
-                        945
+                        943
                     ],
                     "errorMessage": "can only call when creating"
                 },
@@ -488,104 +488,104 @@
                         681,
                         703,
                         725,
-                        776,
-                        798,
-                        820,
-                        842,
-                        864,
-                        886,
-                        908,
-                        931
+                        774,
+                        796,
+                        818,
+                        840,
+                        862,
+                        884,
+                        906,
+                        929
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        1239
+                        1230
                     ],
                     "errorMessage": "check self.arc4_address exists for account"
                 },
                 {
                     "pc": [
-                        1228
+                        1219
                     ],
                     "errorMessage": "check self.arc4_bool exists for account"
                 },
                 {
                     "pc": [
-                        1217
+                        1208
                     ],
                     "errorMessage": "check self.arc4_byte exists for account"
                 },
                 {
                     "pc": [
-                        1261
+                        1252
                     ],
                     "errorMessage": "check self.arc4_dynamic_bytes exists for account"
                 },
                 {
                     "pc": [
-                        1206
+                        1197
                     ],
                     "errorMessage": "check self.arc4_string exists for account"
                 },
                 {
                     "pc": [
-                        1195
+                        1186
                     ],
                     "errorMessage": "check self.arc4_uint exists for account"
                 },
                 {
                     "pc": [
-                        1250
+                        1241
                     ],
                     "errorMessage": "check self.arc4_uint128 exists for account"
                 },
                 {
                     "pc": [
-                        1120
+                        1118
                     ],
                     "errorMessage": "check self.implicit_key_arc4_address exists for account"
                 },
                 {
                     "pc": [
-                        1109
+                        1107
                     ],
                     "errorMessage": "check self.implicit_key_arc4_bool exists for account"
                 },
                 {
                     "pc": [
-                        1098
+                        1096
                     ],
                     "errorMessage": "check self.implicit_key_arc4_byte exists for account"
                 },
                 {
                     "pc": [
-                        1142
+                        1140
                     ],
                     "errorMessage": "check self.implicit_key_arc4_dynamic_bytes exists for account"
                 },
                 {
                     "pc": [
-                        1087
+                        1085
                     ],
                     "errorMessage": "check self.implicit_key_arc4_string exists for account"
                 },
                 {
                     "pc": [
-                        1076
+                        1074
                     ],
                     "errorMessage": "check self.implicit_key_arc4_uint exists for account"
                 },
                 {
                     "pc": [
-                        1131
+                        1129
                     ],
                     "errorMessage": "check self.implicit_key_arc4_uint128 exists for account"
                 },
                 {
                     "pc": [
-                        1153
+                        1151
                     ],
                     "errorMessage": "check self.implicit_key_tuple exists for account"
                 }
@@ -598,19 +598,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.LocalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" 0x0000000000000539 "implicit_key_arc4_string" 0x000548656c6c6f "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" 0x00000010000000000000000000000000 "implicit_key_arc4_dynamic_bytes" 0x000d64796e616d6963206279746573 "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@21
    pushbytess 0x30c6d58a 0x2284b7af 0x26b45756 0xecf633b0 0x3e531223 0x3ed6799d 0x5296d5ca 0x676a87c2 0x25bd1059 0x999b7f2b 0x70666842 0x6521d49b 0xe07c56cd 0xaa19d2b5 0x971b071f 0xfc0feed9 // method "opt_in()void", method "get_implicit_key_arc4_uint(account)uint64", method "get_implicit_key_arc4_string(account)string", method "get_implicit_key_arc4_byte(account)byte", method "get_implicit_key_arc4_bool(account)bool", method "get_implicit_key_arc4_address(account)address", method "get_implicit_key_arc4_uint128(account)uint128", method "get_implicit_key_arc4_dynamic_bytes(account)byte[]", method "get_implicit_key_tuple(account)(uint64,byte[],bool)", method "get_arc4_uint(account)uint64", method "get_arc4_string(account)string", method "get_arc4_byte(account)byte", method "get_arc4_bool(account)bool", method "get_arc4_address(account)address", method "get_arc4_uint128(account)uint128", method "get_arc4_dynamic_bytes(account)byte[]"
    txna ApplicationArgs 0
    match main_opt_in_route@5 main_get_implicit_key_arc4_uint_route@6 main_get_implicit_key_arc4_string_route@7 main_get_implicit_key_arc4_byte_route@8 main_get_implicit_key_arc4_bool_route@9 main_get_implicit_key_arc4_address_route@10 main_get_implicit_key_arc4_uint128_route@11 main_get_implicit_key_arc4_dynamic_bytes_route@12 main_get_implicit_key_tuple_route@13 main_get_arc4_uint_route@14 main_get_arc4_string_route@15 main_get_arc4_byte_route@16 main_get_arc4_bool_route@17 main_get_arc4_address_route@18 main_get_arc4_uint128_route@19 main_get_arc4_dynamic_bytes_route@20

main_after_if_else@23:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    intc_0 // 0
    return

main_get_arc4_dynamic_bytes_route@20:
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint128_route@19:
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_address_route@18:
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_bool_route@17:
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_byte_route@16:
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_string_route@15:
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint_route@14:
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_tuple_route@13:
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    uncover 2
    pushbytes 0x000b
    concat
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@12:
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint128_route@11:
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_address_route@10:
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_bool_route@9:
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_byte_route@8:
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_string_route@7:
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint_route@6:
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:686
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_1 // OptIn
    ==
    assert // OnCompletion is not OptIn
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main_bare_routing@21:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@23
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:688
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec_2 // "implicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 4 // "implicit_key_arc4_string"
    bytec 5 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:690
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 6 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 7 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:692
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    bytec 8 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:693
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:692-694
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:695
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 9 // "implicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:696
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 12 // 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:699
    // self.implicit_key_tuple[Global.creator_address] = (UInt64(10), Bytes(b"test"), False)
    global CreatorAddress
    bytec 13 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_local_put
    // tests/artifacts/StateOps/contract.py:701
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec 14 // "explicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 15 // "explicit_key_arc4_string"
    bytec 5 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:703
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 16 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 17 // "explicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:705
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    bytec 18 // "explicit_key_arc4_address"
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:706
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 19 // "explicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    bytec 12 // 0x000d64796e616d6963206279746573
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint(a: bytes) -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:709-711
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:712
    // return self.implicit_key_arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_string(a: bytes) -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:714-715
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:716
    // return self.implicit_key_arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 4 // "implicit_key_arc4_string"
    app_local_get_ex
    assert // check self.implicit_key_arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_byte(a: bytes) -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:718-719
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:720
    // return self.implicit_key_arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 6 // "implicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.implicit_key_arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_bool(a: bytes) -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:722-723
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:724
    // return self.implicit_key_arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 7 // "implicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.implicit_key_arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_address(a: bytes) -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:726-727
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:728
    // return self.implicit_key_arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 8 // "implicit_key_arc4_address"
    app_local_get_ex
    assert // check self.implicit_key_arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint128(a: bytes) -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:730-731
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:732
    // return self.implicit_key_arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 9 // "implicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_dynamic_bytes(a: bytes) -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:734-735
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:736
    // return self.implicit_key_arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_tuple(a: bytes) -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:738-739
    // @arc4.abimethod()
    // def get_implicit_key_tuple(self, a: Account) -> tuple[UInt64, Bytes, bool]:
    proto 1 3
    // tests/artifacts/StateOps/contract.py:740
    // return self.implicit_key_tuple[a]
    frame_dig -1
    intc_0 // 0
    bytec 13 // "implicit_key_tuple"
    app_local_get_ex
    assert // check self.implicit_key_tuple exists for account
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 8 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    pushint 80 // 80
    getbit
    bytec_1 // 0x00
    intc_0 // 0
    uncover 2
    setbit
    intc_0 // 0
    getbit
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint(a: bytes) -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:742-744
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    // def get_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:745
    // return self.arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec 14 // "explicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_string(a: bytes) -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:747-748
    // @arc4.abimethod()
    // def get_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:749
    // return self.arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 15 // "explicit_key_arc4_string"
    app_local_get_ex
    assert // check self.arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_byte(a: bytes) -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:751-752
    // @arc4.abimethod()
    // def get_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:753
    // return self.arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 16 // "explicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_bool(a: bytes) -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:755-756
    // @arc4.abimethod()
    // def get_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:757
    // return self.arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 17 // "explicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_address(a: bytes) -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:759-760
    // @arc4.abimethod()
    // def get_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:761
    // return self.arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 18 // "explicit_key_arc4_address"
    app_local_get_ex
    assert // check self.arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint128(a: bytes) -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:763-764
    // @arc4.abimethod()
    // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:765
    // return self.arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 19 // "explicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_dynamic_bytes(a: bytes) -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:767-768
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:769
    // return self.arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.LocalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 0 1
    bytecblock 0x151f7c75 0x00 "implicit_key_arc4_uint" 0x0000000000000539 "implicit_key_arc4_string" 0x000548656c6c6f "implicit_key_arc4_byte" "implicit_key_arc4_bool" "implicit_key_arc4_address" "implicit_key_arc4_uint128" 0x00000010000000000000000000000000 "implicit_key_arc4_dynamic_bytes" 0x000d64796e616d6963206279746573 "implicit_key_tuple" "explicit_key_arc4_uint" "explicit_key_arc4_string" "explicit_key_arc4_byte" "explicit_key_arc4_bool" "explicit_key_arc4_address" "explicit_key_arc4_uint128" "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@21
    pushbytess 0x30c6d58a 0x2284b7af 0x26b45756 0xecf633b0 0x3e531223 0x3ed6799d 0x5296d5ca 0x676a87c2 0x25bd1059 0x999b7f2b 0x70666842 0x6521d49b 0xe07c56cd 0xaa19d2b5 0x971b071f 0xfc0feed9 // method "opt_in()void", method "get_implicit_key_arc4_uint(account)uint64", method "get_implicit_key_arc4_string(account)string", method "get_implicit_key_arc4_byte(account)byte", method "get_implicit_key_arc4_bool(account)bool", method "get_implicit_key_arc4_address(account)address", method "get_implicit_key_arc4_uint128(account)uint128", method "get_implicit_key_arc4_dynamic_bytes(account)byte[]", method "get_implicit_key_tuple(account)(uint64,byte[],bool)", method "get_arc4_uint(account)uint64", method "get_arc4_string(account)string", method "get_arc4_byte(account)byte", method "get_arc4_bool(account)bool", method "get_arc4_address(account)address", method "get_arc4_uint128(account)uint128", method "get_arc4_dynamic_bytes(account)byte[]"
    txna ApplicationArgs 0
    match main_opt_in_route@5 main_get_implicit_key_arc4_uint_route@6 main_get_implicit_key_arc4_string_route@7 main_get_implicit_key_arc4_byte_route@8 main_get_implicit_key_arc4_bool_route@9 main_get_implicit_key_arc4_address_route@10 main_get_implicit_key_arc4_uint128_route@11 main_get_implicit_key_arc4_dynamic_bytes_route@12 main_get_implicit_key_tuple_route@13 main_get_arc4_uint_route@14 main_get_arc4_string_route@15 main_get_arc4_byte_route@16 main_get_arc4_bool_route@17 main_get_arc4_address_route@18 main_get_arc4_uint128_route@19 main_get_arc4_dynamic_bytes_route@20

main_after_if_else@23:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    intc_0 // 0
    return

main_get_arc4_dynamic_bytes_route@20:
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:767
    // @arc4.abimethod()
    callsub get_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint128_route@19:
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:763
    // @arc4.abimethod()
    callsub get_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_address_route@18:
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:759
    // @arc4.abimethod()
    callsub get_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_bool_route@17:
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:755
    // @arc4.abimethod()
    callsub get_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_byte_route@16:
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:751
    // @arc4.abimethod()
    callsub get_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_string_route@15:
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:747
    // @arc4.abimethod()
    callsub get_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_arc4_uint_route@14:
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:742-743
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_tuple_route@13:
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:738
    // @arc4.abimethod()
    callsub get_implicit_key_tuple
    uncover 2
    itob
    dig 2
    len
    itob
    extract 6 2
    uncover 3
    concat
    swap
    pushbytes 0x000b
    concat
    bytec_1 // 0x00
    intc_0 // 0
    uncover 4
    setbit
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@12:
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:734
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint128_route@11:
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:730
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_address_route@10:
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:726
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_bool_route@9:
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:722
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_byte_route@8:
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:718
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_string_route@7:
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:714
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_get_implicit_key_arc4_uint_route@6:
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:709-710
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_1 // 1
    return

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:686
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_1 // OptIn
    ==
    assert // OnCompletion is not OptIn
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_1 // 1
    return

main_bare_routing@21:
    // tests/artifacts/StateOps/contract.py:663
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@23
    txn ApplicationID
    !
    assert // can only call when creating
    intc_1 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:688
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec_2 // "implicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 4 // "implicit_key_arc4_string"
    bytec 5 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:690
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 6 // "implicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 7 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:692
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    bytec 8 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:693
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:692-694
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:695
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 9 // "implicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:696
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 12 // 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:699
    // self.implicit_key_tuple[Global.creator_address] = (UInt64(10), Bytes(b"test"), False)
    global CreatorAddress
    bytec 13 // "implicit_key_tuple"
    pushbytes 0x000000000000000a000b00000474657374
    app_local_put
    // tests/artifacts/StateOps/contract.py:701
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec 14 // "explicit_key_arc4_uint"
    bytec_3 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 15 // "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:689
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    bytec 5 // 0x000548656c6c6f
    // tests/artifacts/StateOps/contract.py:702
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    app_local_put
    // tests/artifacts/StateOps/contract.py:703
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 16 // "explicit_key_arc4_byte"
    bytec_1 // 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 17 // "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:691
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    pushbytes 0x80
    // tests/artifacts/StateOps/contract.py:704
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    app_local_put
    // tests/artifacts/StateOps/contract.py:705
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    bytec 18 // "explicit_key_arc4_address"
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:706
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 19 // "explicit_key_arc4_uint128"
    bytec 10 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:696-698
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 12 // 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:707
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint(a: bytes) -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:709-711
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:712
    // return self.implicit_key_arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec_2 // "implicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_string(a: bytes) -> bytes:
get_implicit_key_arc4_string:
    // tests/artifacts/StateOps/contract.py:714-715
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:716
    // return self.implicit_key_arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 4 // "implicit_key_arc4_string"
    app_local_get_ex
    assert // check self.implicit_key_arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_byte(a: bytes) -> bytes:
get_implicit_key_arc4_byte:
    // tests/artifacts/StateOps/contract.py:718-719
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:720
    // return self.implicit_key_arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 6 // "implicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.implicit_key_arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_bool(a: bytes) -> bytes:
get_implicit_key_arc4_bool:
    // tests/artifacts/StateOps/contract.py:722-723
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:724
    // return self.implicit_key_arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 7 // "implicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.implicit_key_arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_address(a: bytes) -> bytes:
get_implicit_key_arc4_address:
    // tests/artifacts/StateOps/contract.py:726-727
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:728
    // return self.implicit_key_arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 8 // "implicit_key_arc4_address"
    app_local_get_ex
    assert // check self.implicit_key_arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint128(a: bytes) -> bytes:
get_implicit_key_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:730-731
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:732
    // return self.implicit_key_arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 9 // "implicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.implicit_key_arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_dynamic_bytes(a: bytes) -> bytes:
get_implicit_key_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:734-735
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:736
    // return self.implicit_key_arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 11 // "implicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_tuple(a: bytes) -> uint64, bytes, uint64:
get_implicit_key_tuple:
    // tests/artifacts/StateOps/contract.py:738-739
    // @arc4.abimethod()
    // def get_implicit_key_tuple(self, a: Account) -> tuple[UInt64, Bytes, bool]:
    proto 1 3
    // tests/artifacts/StateOps/contract.py:740
    // return self.implicit_key_tuple[a]
    frame_dig -1
    intc_0 // 0
    bytec 13 // "implicit_key_tuple"
    app_local_get_ex
    assert // check self.implicit_key_tuple exists for account
    dup
    intc_0 // 0
    extract_uint64
    dig 1
    pushint 8 // 8
    extract_uint16
    dig 2
    len
    dig 3
    cover 2
    substring3
    extract 2 0
    uncover 2
    pushint 80 // 80
    getbit
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint(a: bytes) -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:742-744
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    // def get_arc4_uint(self, a: Account) -> arc4.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:745
    // return self.arc4_uint[a]
    frame_dig -1
    intc_0 // 0
    bytec 14 // "explicit_key_arc4_uint"
    app_local_get_ex
    assert // check self.arc4_uint exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_string(a: bytes) -> bytes:
get_arc4_string:
    // tests/artifacts/StateOps/contract.py:747-748
    // @arc4.abimethod()
    // def get_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:749
    // return self.arc4_string[a]
    frame_dig -1
    intc_0 // 0
    bytec 15 // "explicit_key_arc4_string"
    app_local_get_ex
    assert // check self.arc4_string exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_byte(a: bytes) -> bytes:
get_arc4_byte:
    // tests/artifacts/StateOps/contract.py:751-752
    // @arc4.abimethod()
    // def get_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:753
    // return self.arc4_byte[a]
    frame_dig -1
    intc_0 // 0
    bytec 16 // "explicit_key_arc4_byte"
    app_local_get_ex
    assert // check self.arc4_byte exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_bool(a: bytes) -> bytes:
get_arc4_bool:
    // tests/artifacts/StateOps/contract.py:755-756
    // @arc4.abimethod()
    // def get_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:757
    // return self.arc4_bool[a]
    frame_dig -1
    intc_0 // 0
    bytec 17 // "explicit_key_arc4_bool"
    app_local_get_ex
    assert // check self.arc4_bool exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_address(a: bytes) -> bytes:
get_arc4_address:
    // tests/artifacts/StateOps/contract.py:759-760
    // @arc4.abimethod()
    // def get_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:761
    // return self.arc4_address[a]
    frame_dig -1
    intc_0 // 0
    bytec 18 // "explicit_key_arc4_address"
    app_local_get_ex
    assert // check self.arc4_address exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint128(a: bytes) -> bytes:
get_arc4_uint128:
    // tests/artifacts/StateOps/contract.py:763-764
    // @arc4.abimethod()
    // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:765
    // return self.arc4_uint128[a]
    frame_dig -1
    intc_0 // 0
    bytec 19 // "explicit_key_arc4_uint128"
    app_local_get_ex
    assert // check self.arc4_uint128 exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_dynamic_bytes(a: bytes) -> bytes:
get_arc4_dynamic_bytes:
    // tests/artifacts/StateOps/contract.py:767-768
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:769
    // return self.arc4_dynamic_bytes[a]
    frame_dig -1
    intc_0 // 0
    bytec 20 // "explicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "CiACAAEmFQQVH3x1AQAWaW1wbGljaXRfa2V5X2FyYzRfdWludAgAAAAAAAAFORhpbXBsaWNpdF9rZXlfYXJjNF9zdHJpbmcHAAVIZWxsbxZpbXBsaWNpdF9rZXlfYXJjNF9ieXRlFmltcGxpY2l0X2tleV9hcmM0X2Jvb2wZaW1wbGljaXRfa2V5X2FyYzRfYWRkcmVzcxlpbXBsaWNpdF9rZXlfYXJjNF91aW50MTI4EAAAABAAAAAAAAAAAAAAAAAfaW1wbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcw8ADWR5bmFtaWMgYnl0ZXMSaW1wbGljaXRfa2V5X3R1cGxlFmV4cGxpY2l0X2tleV9hcmM0X3VpbnQYZXhwbGljaXRfa2V5X2FyYzRfc3RyaW5nFmV4cGxpY2l0X2tleV9hcmM0X2J5dGUWZXhwbGljaXRfa2V5X2FyYzRfYm9vbBlleHBsaWNpdF9rZXlfYXJjNF9hZGRyZXNzGWV4cGxpY2l0X2tleV9hcmM0X3VpbnQxMjgfZXhwbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlczEbQQHtghAEMMbVigQihLevBCa0V1YE7PYzsAQ+UxIjBD7WeZ0EUpbVygRnaofCBCW9EFkEmZt/KwRwZmhCBGUh1JsE4HxWzQSqGdK1BJcbBx8E/A/u2TYaAI4QAWkBUwE9AScBEQD7AOUAzwCcAIYAcABaAEQALgAYAAIiQzEZFEQxGEQ2GgEXwByIAp8oTFCwI0MxGRREMRhENhoBF8AciAJ+KExQsCNDMRkURDEYRDYaARfAHIgCXShMULAjQzEZFEQxGEQ2GgEXwByIAjwoTFCwI0MxGRREMRhENhoBF8AciAIbKExQsCNDMRkURDEYRDYaARfAHIgB+ihMULAjQzEZFEQxGEQ2GgEXwByIAdkoTFCwI0MxGRREMRhENhoBF8AciAGZTwIWSwIVFlcGAk8DUCkiTwRUTwKAAgALUExQTFAoTFCwI0MxGRREMRhENhoBF8AciAFbKExQsCNDMRkURDEYRDYaARfAHIgBOihMULAjQzEZFEQxGEQ2GgEXwByIARkoTFCwI0MxGRREMRhENhoBF8AciAD4KExQsCNDMRkURDEYRDYaARfAHIgA1yhMULAjQzEZFEQxGEQ2GgEXwByIALYoTFCwI0MxGRREMRhENhoBF8AciACWKExQsCNDMRkjEkQxGESIAA0jQzEZQP6FMRgURCNDMgkqK2YyCScEJwVmMgknBilmMgknB4ABgGYyCScIMglmMgknCScKZjIJJwsnDGYyCScNgBEAAAAAAAAACgALAAAEdGVzdGYyCScOK2YyCScPJwVmMgknEClmMgknEYABgGYyCScSMglmMgknEycKZjIJJxQnDGaJigEBi/8iKmNEiYoBAYv/IicEY0SJigEBi/8iJwZjRImKAQGL/yInB2NEiYoBAYv/IicIY0SJigEBi/8iJwljRImKAQGL/yInC2NEiYoBA4v/IicNY0RJIltLAYEIWUsCFUsDTgJSVwIATwKBUFMpIk8CVCJTiYoBAYv/IicOY0SJigEBi/8iJw9jRImKAQGL/yInEGNEiYoBAYv/IicRY0SJigEBi/8iJxJjRImKAQGL/yInE2NEiYoBAYv/IicUY0SJ",
+        "approval": "CiACAAEmFQQVH3x1AQAWaW1wbGljaXRfa2V5X2FyYzRfdWludAgAAAAAAAAFORhpbXBsaWNpdF9rZXlfYXJjNF9zdHJpbmcHAAVIZWxsbxZpbXBsaWNpdF9rZXlfYXJjNF9ieXRlFmltcGxpY2l0X2tleV9hcmM0X2Jvb2wZaW1wbGljaXRfa2V5X2FyYzRfYWRkcmVzcxlpbXBsaWNpdF9rZXlfYXJjNF91aW50MTI4EAAAABAAAAAAAAAAAAAAAAAfaW1wbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlcw8ADWR5bmFtaWMgYnl0ZXMSaW1wbGljaXRfa2V5X3R1cGxlFmV4cGxpY2l0X2tleV9hcmM0X3VpbnQYZXhwbGljaXRfa2V5X2FyYzRfc3RyaW5nFmV4cGxpY2l0X2tleV9hcmM0X2J5dGUWZXhwbGljaXRfa2V5X2FyYzRfYm9vbBlleHBsaWNpdF9rZXlfYXJjNF9hZGRyZXNzGWV4cGxpY2l0X2tleV9hcmM0X3VpbnQxMjgfZXhwbGljaXRfa2V5X2FyYzRfZHluYW1pY19ieXRlczEbQQHrghAEMMbVigQihLevBCa0V1YE7PYzsAQ+UxIjBD7WeZ0EUpbVygRnaofCBCW9EFkEmZt/KwRwZmhCBGUh1JsE4HxWzQSqGdK1BJcbBx8E/A/u2TYaAI4QAWcBUQE7ASUBDwD5AOMAzQCcAIYAcABaAEQALgAYAAIiQzEZFEQxGEQ2GgEXwByIApYoTFCwI0MxGRREMRhENhoBF8AciAJ1KExQsCNDMRkURDEYRDYaARfAHIgCVChMULAjQzEZFEQxGEQ2GgEXwByIAjMoTFCwI0MxGRREMRhENhoBF8AciAISKExQsCNDMRkURDEYRDYaARfAHIgB8ShMULAjQzEZFEQxGEQ2GgEXwByIAdAoTFCwI0MxGRREMRhENhoBF8AciAGXTwIWSwIVFlcGAk8DUEyAAgALUCkiTwRUUExQKExQsCNDMRkURDEYRDYaARfAHIgBWyhMULAjQzEZFEQxGEQ2GgEXwByIATooTFCwI0MxGRREMRhENhoBF8AciAEZKExQsCNDMRkURDEYRDYaARfAHIgA+ChMULAjQzEZFEQxGEQ2GgEXwByIANcoTFCwI0MxGRREMRhENhoBF8AciAC2KExQsCNDMRkURDEYRDYaARfAHIgAlihMULAjQzEZIxJEMRhEiAANI0MxGUD+hzEYFEQjQzIJKitmMgknBCcFZjIJJwYpZjIJJweAAYBmMgknCDIJZjIJJwknCmYyCScLJwxmMgknDYARAAAAAAAAAAoACwAABHRlc3RmMgknDitmMgknDycFZjIJJxApZjIJJxGAAYBmMgknEjIJZjIJJxMnCmYyCScUJwxmiYoBAYv/IipjRImKAQGL/yInBGNEiYoBAYv/IicGY0SJigEBi/8iJwdjRImKAQGL/yInCGNEiYoBAYv/IicJY0SJigEBi/8iJwtjRImKAQOL/yInDWNESSJbSwGBCFlLAhVLA04CUlcCAE8CgVBTiYoBAYv/IicOY0SJigEBi/8iJw9jRImKAQGL/yInEGNEiYoBAYv/IicRY0SJigEBi/8iJxJjRImKAQGL/yInE2NEiYoBAYv/IicUY0SJ",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal
index 6c9896f2..b2b5d81e 100644
--- a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal
@@ -439,15 +439,13 @@ verify_acct_balance:
     // return op.btoi(Txn.application_args(1))
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/StateOps/contract.py:33
-    // assert value == algopy.op.balance(_get_1st_ref_index()), (
+    // tests/artifacts/StateOps/contract.py:33-35
+    // assert value == algopy.op.balance(
+    //     _get_1st_ref_index()
+    // ), "expected op.balance by index to match"
     balance
     dig 1
     ==
-    // tests/artifacts/StateOps/contract.py:33-35
-    // assert value == algopy.op.balance(_get_1st_ref_index()), (
-    //     "expected op.balance by index to match"
-    // )
     assert // expected op.balance by index to match
     // tests/artifacts/StateOps/contract.py:36
     // return value
@@ -500,15 +498,13 @@ verify_acct_min_balance:
     // return op.btoi(Txn.application_args(1))
     txna ApplicationArgs 1
     btoi
-    // tests/artifacts/StateOps/contract.py:46
-    // assert value == algopy.op.min_balance(_get_1st_ref_index()), (
+    // tests/artifacts/StateOps/contract.py:46-48
+    // assert value == algopy.op.min_balance(
+    //     _get_1st_ref_index()
+    // ), "expected op.min_balance by index to match"
     min_balance
     dig 1
     ==
-    // tests/artifacts/StateOps/contract.py:46-48
-    // assert value == algopy.op.min_balance(_get_1st_ref_index()), (
-    //     "expected op.min_balance by index to match"
-    // )
     assert // expected op.min_balance by index to match
     // tests/artifacts/StateOps/contract.py:49
     // return value
diff --git a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json
index 68ffcbb6..628dde32 100644
--- a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json
@@ -77,7 +77,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn NumAppArgs
    bz main_bare_routing@20
    pushbytess 0x5f5b43e4 0x73dc93c7 0x5626dfeb 0xdc8a25bf 0x198ebd8c 0x2301ab26 0x9f68fca6 0xa975c2d1 0xd1e04801 0xb6966be5 0x195d5418 0x6adae3f1 0xdf8cfee5 0x6ad70d21 0x1735fd22 // method "verify_acct_balance(account)uint64", method "verify_acct_min_balance(account)uint64", method "verify_acct_auth_addr(account)address", method "verify_acct_total_num_uint(account)uint64", method "verify_acct_total_num_byte_slice(account)uint64", method "verify_acct_total_extra_app_pages(account)uint64", method "verify_acct_total_apps_created(account)uint64", method "verify_acct_total_apps_opted_in(account)uint64", method "verify_acct_total_assets_created(account)uint64", method "verify_acct_total_assets(account)uint64", method "verify_acct_total_boxes(account)uint64", method "verify_acct_total_box_bytes(account)uint64", method "verify_acct_incentive_eligible(account)bool", method "verify_acct_last_heartbeat(account)uint64", method "verify_acct_last_proposed(account)uint64"
    txna ApplicationArgs 0
    match main_verify_acct_balance_route@3 main_verify_acct_min_balance_route@4 main_verify_acct_auth_addr_route@5 main_verify_acct_total_num_uint_route@6 main_verify_acct_total_num_byte_slice_route@7 main_verify_acct_total_extra_app_pages_route@8 main_verify_acct_total_apps_created_route@9 main_verify_acct_total_apps_opted_in_route@10 main_verify_acct_total_assets_created_route@11 main_verify_acct_total_assets_route@12 main_verify_acct_total_boxes_route@13 main_verify_acct_total_box_bytes_route@14 main_verify_acct_incentive_eligible_route@15 main_verify_acct_last_heartbeat_route@16 main_verify_acct_last_proposed_route@17

main_after_if_else@24:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    intc_1 // 0
    return

main_verify_acct_last_proposed_route@17:
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    callsub verify_acct_last_proposed
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_last_heartbeat_route@16:
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_acct_last_heartbeat
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_incentive_eligible_route@15:
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    callsub verify_acct_incentive_eligible
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_box_bytes_route@14:
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    callsub verify_acct_total_box_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_boxes_route@13:
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_acct_total_boxes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_route@12:
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    callsub verify_acct_total_assets
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_created_route@11:
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_acct_total_assets_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_opted_in_route@10:
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    callsub verify_acct_total_apps_opted_in
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_created_route@9:
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_acct_total_apps_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_extra_app_pages_route@8:
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_acct_total_extra_app_pages
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_byte_slice_route@7:
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_acct_total_num_byte_slice
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_uint_route@6:
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    callsub verify_acct_total_num_uint
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_auth_addr_route@5:
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    callsub verify_acct_auth_addr
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_min_balance_route@4:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    callsub verify_acct_min_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_balance_route@3:
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_acct_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@20:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn OnCompletion
    bnz main_after_if_else@24
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_balance(a: bytes) -> uint64:
verify_acct_balance:
    // tests/artifacts/StateOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:27
    // value, funded = op.AcctParamsGet.acct_balance(a)
    frame_dig -1
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:28
    // value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:29
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:30
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:31
    // assert value == a.balance, "expected Account balance to match"
    frame_dig -1
    acct_params_get AcctBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account balance to match
    // tests/artifacts/StateOps/contract.py:32
    // assert value == algopy.op.balance(a), "expected op.balance to match"
    frame_dig -1
    balance
    dig 1
    ==
    assert // expected op.balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:33
    // assert value == algopy.op.balance(_get_1st_ref_index()), (
    balance
    dig 1
    ==
    // tests/artifacts/StateOps/contract.py:33-35
    // assert value == algopy.op.balance(_get_1st_ref_index()), (
    //     "expected op.balance by index to match"
    // )
    assert // expected op.balance by index to match
    // tests/artifacts/StateOps/contract.py:36
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_min_balance(a: bytes) -> uint64:
verify_acct_min_balance:
    // tests/artifacts/StateOps/contract.py:38-39
    // @arc4.abimethod()
    // def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:40
    // value, funded = op.AcctParamsGet.acct_min_balance(a)
    frame_dig -1
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:41
    // value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:42
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:43
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:44
    // assert value == a.min_balance, "expected Account min_balance to match"
    frame_dig -1
    acct_params_get AcctMinBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account min_balance to match
    // tests/artifacts/StateOps/contract.py:45
    // assert value == algopy.op.min_balance(a), "expected op.min_balance to match"
    frame_dig -1
    min_balance
    dig 1
    ==
    assert // expected op.min_balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:46
    // assert value == algopy.op.min_balance(_get_1st_ref_index()), (
    min_balance
    dig 1
    ==
    // tests/artifacts/StateOps/contract.py:46-48
    // assert value == algopy.op.min_balance(_get_1st_ref_index()), (
    //     "expected op.min_balance by index to match"
    // )
    assert // expected op.min_balance by index to match
    // tests/artifacts/StateOps/contract.py:49
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_auth_addr(a: bytes) -> bytes:
verify_acct_auth_addr:
    // tests/artifacts/StateOps/contract.py:51-52
    // @arc4.abimethod()
    // def verify_acct_auth_addr(self, a: algopy.Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:53
    // value, funded = op.AcctParamsGet.acct_auth_addr(a)
    frame_dig -1
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:54
    // value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:55
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:56
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:57
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_uint(a: bytes) -> uint64:
verify_acct_total_num_uint:
    // tests/artifacts/StateOps/contract.py:59-60
    // @arc4.abimethod()
    // def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:61
    // value, funded = op.AcctParamsGet.acct_total_num_uint(a)
    frame_dig -1
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:62
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:63
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:64
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:65
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_byte_slice(a: bytes) -> uint64:
verify_acct_total_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:69
    // value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
    frame_dig -1
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:70-72
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_byte_slice(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:73
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:74
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:75
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_extra_app_pages(a: bytes) -> uint64:
verify_acct_total_extra_app_pages:
    // tests/artifacts/StateOps/contract.py:77-78
    // @arc4.abimethod()
    // def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:79
    // value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
    frame_dig -1
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:80-82
    // value_index, funded_index = op.AcctParamsGet.acct_total_extra_app_pages(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:83
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:84
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:85
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_created(a: bytes) -> uint64:
verify_acct_total_apps_created:
    // tests/artifacts/StateOps/contract.py:87-88
    // @arc4.abimethod()
    // def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:89
    // value, funded = op.AcctParamsGet.acct_total_apps_created(a)
    frame_dig -1
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:90
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:91
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:92
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:93
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_opted_in(a: bytes) -> uint64:
verify_acct_total_apps_opted_in:
    // tests/artifacts/StateOps/contract.py:95-96
    // @arc4.abimethod()
    // def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:97
    // value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
    frame_dig -1
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:98
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:99
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:100
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:101
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets_created(a: bytes) -> uint64:
verify_acct_total_assets_created:
    // tests/artifacts/StateOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:105
    // value, funded = op.AcctParamsGet.acct_total_assets_created(a)
    frame_dig -1
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:106-108
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets_created(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:109
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:110
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:111
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets(a: bytes) -> uint64:
verify_acct_total_assets:
    // tests/artifacts/StateOps/contract.py:113-114
    // @arc4.abimethod()
    // def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:115
    // value, funded = op.AcctParamsGet.acct_total_assets(a)
    frame_dig -1
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:116
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:117
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:118
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:119
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_boxes(a: bytes) -> uint64:
verify_acct_total_boxes:
    // tests/artifacts/StateOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:123
    // value, funded = op.AcctParamsGet.acct_total_boxes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:124
    // value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:125
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:126
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:127
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_box_bytes(a: bytes) -> uint64:
verify_acct_total_box_bytes:
    // tests/artifacts/StateOps/contract.py:129-130
    // @arc4.abimethod()
    // def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:131
    // value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:132
    // value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:133
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:134
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:135
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_incentive_eligible(a: bytes) -> uint64:
verify_acct_incentive_eligible:
    // tests/artifacts/StateOps/contract.py:137-138
    // @arc4.abimethod()
    // def verify_acct_incentive_eligible(self, a: algopy.Account) -> bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:139
    // value, funded = op.AcctParamsGet.acct_incentive_eligible(a)
    frame_dig -1
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:140
    // value_index, funded_index = op.AcctParamsGet.acct_incentive_eligible(_get_1st_ref_index())
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:141
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:142
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:143
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_heartbeat(a: bytes) -> uint64:
verify_acct_last_heartbeat:
    // tests/artifacts/StateOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_acct_last_heartbeat(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:147
    // value, funded = op.AcctParamsGet.acct_last_heartbeat(a)
    frame_dig -1
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:148
    // value_index, funded_index = op.AcctParamsGet.acct_last_heartbeat(_get_1st_ref_index())
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:149
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:150
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:151
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_proposed(a: bytes) -> uint64:
verify_acct_last_proposed:
    // tests/artifacts/StateOps/contract.py:153-154
    // @arc4.abimethod()
    // def verify_acct_last_proposed(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:155
    // value, funded = op.AcctParamsGet.acct_last_proposed(a)
    frame_dig -1
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:156
    // value_index, funded_index = op.AcctParamsGet.acct_last_proposed(_get_1st_ref_index())
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:157
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:158
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:159
    // return value
    retsub
",
+        "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn NumAppArgs
    bz main_bare_routing@20
    pushbytess 0x5f5b43e4 0x73dc93c7 0x5626dfeb 0xdc8a25bf 0x198ebd8c 0x2301ab26 0x9f68fca6 0xa975c2d1 0xd1e04801 0xb6966be5 0x195d5418 0x6adae3f1 0xdf8cfee5 0x6ad70d21 0x1735fd22 // method "verify_acct_balance(account)uint64", method "verify_acct_min_balance(account)uint64", method "verify_acct_auth_addr(account)address", method "verify_acct_total_num_uint(account)uint64", method "verify_acct_total_num_byte_slice(account)uint64", method "verify_acct_total_extra_app_pages(account)uint64", method "verify_acct_total_apps_created(account)uint64", method "verify_acct_total_apps_opted_in(account)uint64", method "verify_acct_total_assets_created(account)uint64", method "verify_acct_total_assets(account)uint64", method "verify_acct_total_boxes(account)uint64", method "verify_acct_total_box_bytes(account)uint64", method "verify_acct_incentive_eligible(account)bool", method "verify_acct_last_heartbeat(account)uint64", method "verify_acct_last_proposed(account)uint64"
    txna ApplicationArgs 0
    match main_verify_acct_balance_route@3 main_verify_acct_min_balance_route@4 main_verify_acct_auth_addr_route@5 main_verify_acct_total_num_uint_route@6 main_verify_acct_total_num_byte_slice_route@7 main_verify_acct_total_extra_app_pages_route@8 main_verify_acct_total_apps_created_route@9 main_verify_acct_total_apps_opted_in_route@10 main_verify_acct_total_assets_created_route@11 main_verify_acct_total_assets_route@12 main_verify_acct_total_boxes_route@13 main_verify_acct_total_box_bytes_route@14 main_verify_acct_incentive_eligible_route@15 main_verify_acct_last_heartbeat_route@16 main_verify_acct_last_proposed_route@17

main_after_if_else@24:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    intc_1 // 0
    return

main_verify_acct_last_proposed_route@17:
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    callsub verify_acct_last_proposed
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_last_heartbeat_route@16:
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_acct_last_heartbeat
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_incentive_eligible_route@15:
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    callsub verify_acct_incentive_eligible
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_box_bytes_route@14:
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    callsub verify_acct_total_box_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_boxes_route@13:
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_acct_total_boxes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_route@12:
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    callsub verify_acct_total_assets
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_created_route@11:
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_acct_total_assets_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_opted_in_route@10:
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    callsub verify_acct_total_apps_opted_in
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_created_route@9:
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_acct_total_apps_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_extra_app_pages_route@8:
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_acct_total_extra_app_pages
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_byte_slice_route@7:
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_acct_total_num_byte_slice
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_uint_route@6:
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    callsub verify_acct_total_num_uint
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_auth_addr_route@5:
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    callsub verify_acct_auth_addr
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_min_balance_route@4:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    callsub verify_acct_min_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_balance_route@3:
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_acct_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@20:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn OnCompletion
    bnz main_after_if_else@24
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_balance(a: bytes) -> uint64:
verify_acct_balance:
    // tests/artifacts/StateOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:27
    // value, funded = op.AcctParamsGet.acct_balance(a)
    frame_dig -1
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:28
    // value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:29
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:30
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:31
    // assert value == a.balance, "expected Account balance to match"
    frame_dig -1
    acct_params_get AcctBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account balance to match
    // tests/artifacts/StateOps/contract.py:32
    // assert value == algopy.op.balance(a), "expected op.balance to match"
    frame_dig -1
    balance
    dig 1
    ==
    assert // expected op.balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:33-35
    // assert value == algopy.op.balance(
    //     _get_1st_ref_index()
    // ), "expected op.balance by index to match"
    balance
    dig 1
    ==
    assert // expected op.balance by index to match
    // tests/artifacts/StateOps/contract.py:36
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_min_balance(a: bytes) -> uint64:
verify_acct_min_balance:
    // tests/artifacts/StateOps/contract.py:38-39
    // @arc4.abimethod()
    // def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:40
    // value, funded = op.AcctParamsGet.acct_min_balance(a)
    frame_dig -1
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:41
    // value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:42
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:43
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:44
    // assert value == a.min_balance, "expected Account min_balance to match"
    frame_dig -1
    acct_params_get AcctMinBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account min_balance to match
    // tests/artifacts/StateOps/contract.py:45
    // assert value == algopy.op.min_balance(a), "expected op.min_balance to match"
    frame_dig -1
    min_balance
    dig 1
    ==
    assert // expected op.min_balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:46-48
    // assert value == algopy.op.min_balance(
    //     _get_1st_ref_index()
    // ), "expected op.min_balance by index to match"
    min_balance
    dig 1
    ==
    assert // expected op.min_balance by index to match
    // tests/artifacts/StateOps/contract.py:49
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_auth_addr(a: bytes) -> bytes:
verify_acct_auth_addr:
    // tests/artifacts/StateOps/contract.py:51-52
    // @arc4.abimethod()
    // def verify_acct_auth_addr(self, a: algopy.Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:53
    // value, funded = op.AcctParamsGet.acct_auth_addr(a)
    frame_dig -1
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:54
    // value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:55
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:56
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:57
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_uint(a: bytes) -> uint64:
verify_acct_total_num_uint:
    // tests/artifacts/StateOps/contract.py:59-60
    // @arc4.abimethod()
    // def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:61
    // value, funded = op.AcctParamsGet.acct_total_num_uint(a)
    frame_dig -1
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:62
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:63
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:64
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:65
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_byte_slice(a: bytes) -> uint64:
verify_acct_total_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:69
    // value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
    frame_dig -1
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:70-72
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_byte_slice(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:73
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:74
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:75
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_extra_app_pages(a: bytes) -> uint64:
verify_acct_total_extra_app_pages:
    // tests/artifacts/StateOps/contract.py:77-78
    // @arc4.abimethod()
    // def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:79
    // value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
    frame_dig -1
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:80-82
    // value_index, funded_index = op.AcctParamsGet.acct_total_extra_app_pages(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:83
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:84
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:85
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_created(a: bytes) -> uint64:
verify_acct_total_apps_created:
    // tests/artifacts/StateOps/contract.py:87-88
    // @arc4.abimethod()
    // def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:89
    // value, funded = op.AcctParamsGet.acct_total_apps_created(a)
    frame_dig -1
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:90
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:91
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:92
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:93
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_opted_in(a: bytes) -> uint64:
verify_acct_total_apps_opted_in:
    // tests/artifacts/StateOps/contract.py:95-96
    // @arc4.abimethod()
    // def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:97
    // value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
    frame_dig -1
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:98
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:99
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:100
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:101
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets_created(a: bytes) -> uint64:
verify_acct_total_assets_created:
    // tests/artifacts/StateOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:105
    // value, funded = op.AcctParamsGet.acct_total_assets_created(a)
    frame_dig -1
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:106-108
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets_created(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:109
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:110
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:111
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets(a: bytes) -> uint64:
verify_acct_total_assets:
    // tests/artifacts/StateOps/contract.py:113-114
    // @arc4.abimethod()
    // def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:115
    // value, funded = op.AcctParamsGet.acct_total_assets(a)
    frame_dig -1
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:116
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:117
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:118
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:119
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_boxes(a: bytes) -> uint64:
verify_acct_total_boxes:
    // tests/artifacts/StateOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:123
    // value, funded = op.AcctParamsGet.acct_total_boxes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:124
    // value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:125
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:126
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:127
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_box_bytes(a: bytes) -> uint64:
verify_acct_total_box_bytes:
    // tests/artifacts/StateOps/contract.py:129-130
    // @arc4.abimethod()
    // def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:131
    // value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:132
    // value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:133
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:134
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:135
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_incentive_eligible(a: bytes) -> uint64:
verify_acct_incentive_eligible:
    // tests/artifacts/StateOps/contract.py:137-138
    // @arc4.abimethod()
    // def verify_acct_incentive_eligible(self, a: algopy.Account) -> bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:139
    // value, funded = op.AcctParamsGet.acct_incentive_eligible(a)
    frame_dig -1
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:140
    // value_index, funded_index = op.AcctParamsGet.acct_incentive_eligible(_get_1st_ref_index())
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:141
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:142
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:143
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_heartbeat(a: bytes) -> uint64:
verify_acct_last_heartbeat:
    // tests/artifacts/StateOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_acct_last_heartbeat(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:147
    // value, funded = op.AcctParamsGet.acct_last_heartbeat(a)
    frame_dig -1
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:148
    // value_index, funded_index = op.AcctParamsGet.acct_last_heartbeat(_get_1st_ref_index())
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:149
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:150
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:151
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_proposed(a: bytes) -> uint64:
verify_acct_last_proposed:
    // tests/artifacts/StateOps/contract.py:153-154
    // @arc4.abimethod()
    // def verify_acct_last_proposed(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:155
    // value, funded = op.AcctParamsGet.acct_last_proposed(a)
    frame_dig -1
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:156
    // value_index, funded_index = op.AcctParamsGet.acct_last_proposed(_get_1st_ref_index())
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:157
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:158
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:159
    // return value
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc56.json b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc56.json
index cfde4742..4b6388bb 100644
--- a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc56.json
@@ -492,7 +492,7 @@
         }
     },
     "source": {
-        "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn NumAppArgs
    bz main_bare_routing@20
    pushbytess 0x5f5b43e4 0x73dc93c7 0x5626dfeb 0xdc8a25bf 0x198ebd8c 0x2301ab26 0x9f68fca6 0xa975c2d1 0xd1e04801 0xb6966be5 0x195d5418 0x6adae3f1 0xdf8cfee5 0x6ad70d21 0x1735fd22 // method "verify_acct_balance(account)uint64", method "verify_acct_min_balance(account)uint64", method "verify_acct_auth_addr(account)address", method "verify_acct_total_num_uint(account)uint64", method "verify_acct_total_num_byte_slice(account)uint64", method "verify_acct_total_extra_app_pages(account)uint64", method "verify_acct_total_apps_created(account)uint64", method "verify_acct_total_apps_opted_in(account)uint64", method "verify_acct_total_assets_created(account)uint64", method "verify_acct_total_assets(account)uint64", method "verify_acct_total_boxes(account)uint64", method "verify_acct_total_box_bytes(account)uint64", method "verify_acct_incentive_eligible(account)bool", method "verify_acct_last_heartbeat(account)uint64", method "verify_acct_last_proposed(account)uint64"
    txna ApplicationArgs 0
    match main_verify_acct_balance_route@3 main_verify_acct_min_balance_route@4 main_verify_acct_auth_addr_route@5 main_verify_acct_total_num_uint_route@6 main_verify_acct_total_num_byte_slice_route@7 main_verify_acct_total_extra_app_pages_route@8 main_verify_acct_total_apps_created_route@9 main_verify_acct_total_apps_opted_in_route@10 main_verify_acct_total_assets_created_route@11 main_verify_acct_total_assets_route@12 main_verify_acct_total_boxes_route@13 main_verify_acct_total_box_bytes_route@14 main_verify_acct_incentive_eligible_route@15 main_verify_acct_last_heartbeat_route@16 main_verify_acct_last_proposed_route@17

main_after_if_else@24:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    intc_1 // 0
    return

main_verify_acct_last_proposed_route@17:
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    callsub verify_acct_last_proposed
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_last_heartbeat_route@16:
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_acct_last_heartbeat
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_incentive_eligible_route@15:
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    callsub verify_acct_incentive_eligible
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_box_bytes_route@14:
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    callsub verify_acct_total_box_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_boxes_route@13:
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_acct_total_boxes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_route@12:
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    callsub verify_acct_total_assets
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_created_route@11:
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_acct_total_assets_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_opted_in_route@10:
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    callsub verify_acct_total_apps_opted_in
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_created_route@9:
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_acct_total_apps_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_extra_app_pages_route@8:
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_acct_total_extra_app_pages
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_byte_slice_route@7:
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_acct_total_num_byte_slice
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_uint_route@6:
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    callsub verify_acct_total_num_uint
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_auth_addr_route@5:
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    callsub verify_acct_auth_addr
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_min_balance_route@4:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    callsub verify_acct_min_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_balance_route@3:
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_acct_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@20:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn OnCompletion
    bnz main_after_if_else@24
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_balance(a: bytes) -> uint64:
verify_acct_balance:
    // tests/artifacts/StateOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:27
    // value, funded = op.AcctParamsGet.acct_balance(a)
    frame_dig -1
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:28
    // value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:29
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:30
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:31
    // assert value == a.balance, "expected Account balance to match"
    frame_dig -1
    acct_params_get AcctBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account balance to match
    // tests/artifacts/StateOps/contract.py:32
    // assert value == algopy.op.balance(a), "expected op.balance to match"
    frame_dig -1
    balance
    dig 1
    ==
    assert // expected op.balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:33
    // assert value == algopy.op.balance(_get_1st_ref_index()), (
    balance
    dig 1
    ==
    // tests/artifacts/StateOps/contract.py:33-35
    // assert value == algopy.op.balance(_get_1st_ref_index()), (
    //     "expected op.balance by index to match"
    // )
    assert // expected op.balance by index to match
    // tests/artifacts/StateOps/contract.py:36
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_min_balance(a: bytes) -> uint64:
verify_acct_min_balance:
    // tests/artifacts/StateOps/contract.py:38-39
    // @arc4.abimethod()
    // def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:40
    // value, funded = op.AcctParamsGet.acct_min_balance(a)
    frame_dig -1
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:41
    // value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:42
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:43
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:44
    // assert value == a.min_balance, "expected Account min_balance to match"
    frame_dig -1
    acct_params_get AcctMinBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account min_balance to match
    // tests/artifacts/StateOps/contract.py:45
    // assert value == algopy.op.min_balance(a), "expected op.min_balance to match"
    frame_dig -1
    min_balance
    dig 1
    ==
    assert // expected op.min_balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:46
    // assert value == algopy.op.min_balance(_get_1st_ref_index()), (
    min_balance
    dig 1
    ==
    // tests/artifacts/StateOps/contract.py:46-48
    // assert value == algopy.op.min_balance(_get_1st_ref_index()), (
    //     "expected op.min_balance by index to match"
    // )
    assert // expected op.min_balance by index to match
    // tests/artifacts/StateOps/contract.py:49
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_auth_addr(a: bytes) -> bytes:
verify_acct_auth_addr:
    // tests/artifacts/StateOps/contract.py:51-52
    // @arc4.abimethod()
    // def verify_acct_auth_addr(self, a: algopy.Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:53
    // value, funded = op.AcctParamsGet.acct_auth_addr(a)
    frame_dig -1
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:54
    // value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:55
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:56
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:57
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_uint(a: bytes) -> uint64:
verify_acct_total_num_uint:
    // tests/artifacts/StateOps/contract.py:59-60
    // @arc4.abimethod()
    // def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:61
    // value, funded = op.AcctParamsGet.acct_total_num_uint(a)
    frame_dig -1
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:62
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:63
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:64
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:65
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_byte_slice(a: bytes) -> uint64:
verify_acct_total_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:69
    // value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
    frame_dig -1
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:70-72
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_byte_slice(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:73
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:74
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:75
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_extra_app_pages(a: bytes) -> uint64:
verify_acct_total_extra_app_pages:
    // tests/artifacts/StateOps/contract.py:77-78
    // @arc4.abimethod()
    // def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:79
    // value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
    frame_dig -1
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:80-82
    // value_index, funded_index = op.AcctParamsGet.acct_total_extra_app_pages(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:83
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:84
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:85
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_created(a: bytes) -> uint64:
verify_acct_total_apps_created:
    // tests/artifacts/StateOps/contract.py:87-88
    // @arc4.abimethod()
    // def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:89
    // value, funded = op.AcctParamsGet.acct_total_apps_created(a)
    frame_dig -1
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:90
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:91
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:92
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:93
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_opted_in(a: bytes) -> uint64:
verify_acct_total_apps_opted_in:
    // tests/artifacts/StateOps/contract.py:95-96
    // @arc4.abimethod()
    // def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:97
    // value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
    frame_dig -1
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:98
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:99
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:100
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:101
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets_created(a: bytes) -> uint64:
verify_acct_total_assets_created:
    // tests/artifacts/StateOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:105
    // value, funded = op.AcctParamsGet.acct_total_assets_created(a)
    frame_dig -1
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:106-108
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets_created(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:109
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:110
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:111
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets(a: bytes) -> uint64:
verify_acct_total_assets:
    // tests/artifacts/StateOps/contract.py:113-114
    // @arc4.abimethod()
    // def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:115
    // value, funded = op.AcctParamsGet.acct_total_assets(a)
    frame_dig -1
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:116
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:117
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:118
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:119
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_boxes(a: bytes) -> uint64:
verify_acct_total_boxes:
    // tests/artifacts/StateOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:123
    // value, funded = op.AcctParamsGet.acct_total_boxes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:124
    // value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:125
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:126
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:127
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_box_bytes(a: bytes) -> uint64:
verify_acct_total_box_bytes:
    // tests/artifacts/StateOps/contract.py:129-130
    // @arc4.abimethod()
    // def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:131
    // value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:132
    // value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:133
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:134
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:135
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_incentive_eligible(a: bytes) -> uint64:
verify_acct_incentive_eligible:
    // tests/artifacts/StateOps/contract.py:137-138
    // @arc4.abimethod()
    // def verify_acct_incentive_eligible(self, a: algopy.Account) -> bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:139
    // value, funded = op.AcctParamsGet.acct_incentive_eligible(a)
    frame_dig -1
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:140
    // value_index, funded_index = op.AcctParamsGet.acct_incentive_eligible(_get_1st_ref_index())
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:141
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:142
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:143
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_heartbeat(a: bytes) -> uint64:
verify_acct_last_heartbeat:
    // tests/artifacts/StateOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_acct_last_heartbeat(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:147
    // value, funded = op.AcctParamsGet.acct_last_heartbeat(a)
    frame_dig -1
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:148
    // value_index, funded_index = op.AcctParamsGet.acct_last_heartbeat(_get_1st_ref_index())
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:149
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:150
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:151
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_proposed(a: bytes) -> uint64:
verify_acct_last_proposed:
    // tests/artifacts/StateOps/contract.py:153-154
    // @arc4.abimethod()
    // def verify_acct_last_proposed(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:155
    // value, funded = op.AcctParamsGet.acct_last_proposed(a)
    frame_dig -1
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:156
    // value_index, funded_index = op.AcctParamsGet.acct_last_proposed(_get_1st_ref_index())
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:157
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:158
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:159
    // return value
    retsub
",
+        "approval": "#pragma version 11
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn NumAppArgs
    bz main_bare_routing@20
    pushbytess 0x5f5b43e4 0x73dc93c7 0x5626dfeb 0xdc8a25bf 0x198ebd8c 0x2301ab26 0x9f68fca6 0xa975c2d1 0xd1e04801 0xb6966be5 0x195d5418 0x6adae3f1 0xdf8cfee5 0x6ad70d21 0x1735fd22 // method "verify_acct_balance(account)uint64", method "verify_acct_min_balance(account)uint64", method "verify_acct_auth_addr(account)address", method "verify_acct_total_num_uint(account)uint64", method "verify_acct_total_num_byte_slice(account)uint64", method "verify_acct_total_extra_app_pages(account)uint64", method "verify_acct_total_apps_created(account)uint64", method "verify_acct_total_apps_opted_in(account)uint64", method "verify_acct_total_assets_created(account)uint64", method "verify_acct_total_assets(account)uint64", method "verify_acct_total_boxes(account)uint64", method "verify_acct_total_box_bytes(account)uint64", method "verify_acct_incentive_eligible(account)bool", method "verify_acct_last_heartbeat(account)uint64", method "verify_acct_last_proposed(account)uint64"
    txna ApplicationArgs 0
    match main_verify_acct_balance_route@3 main_verify_acct_min_balance_route@4 main_verify_acct_auth_addr_route@5 main_verify_acct_total_num_uint_route@6 main_verify_acct_total_num_byte_slice_route@7 main_verify_acct_total_extra_app_pages_route@8 main_verify_acct_total_apps_created_route@9 main_verify_acct_total_apps_opted_in_route@10 main_verify_acct_total_assets_created_route@11 main_verify_acct_total_assets_route@12 main_verify_acct_total_boxes_route@13 main_verify_acct_total_box_bytes_route@14 main_verify_acct_incentive_eligible_route@15 main_verify_acct_last_heartbeat_route@16 main_verify_acct_last_proposed_route@17

main_after_if_else@24:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    intc_1 // 0
    return

main_verify_acct_last_proposed_route@17:
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:153
    // @arc4.abimethod()
    callsub verify_acct_last_proposed
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_last_heartbeat_route@16:
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:145
    // @arc4.abimethod()
    callsub verify_acct_last_heartbeat
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_incentive_eligible_route@15:
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:137
    // @arc4.abimethod()
    callsub verify_acct_incentive_eligible
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_box_bytes_route@14:
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    callsub verify_acct_total_box_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_boxes_route@13:
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_acct_total_boxes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_route@12:
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    callsub verify_acct_total_assets
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_assets_created_route@11:
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_acct_total_assets_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_opted_in_route@10:
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    callsub verify_acct_total_apps_opted_in
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_apps_created_route@9:
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_acct_total_apps_created
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_extra_app_pages_route@8:
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_acct_total_extra_app_pages
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_byte_slice_route@7:
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_acct_total_num_byte_slice
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_total_num_uint_route@6:
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    callsub verify_acct_total_num_uint
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_auth_addr_route@5:
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    callsub verify_acct_auth_addr
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_min_balance_route@4:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    callsub verify_acct_min_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_acct_balance_route@3:
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_acct_balance
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@20:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
    txn OnCompletion
    bnz main_after_if_else@24
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_balance(a: bytes) -> uint64:
verify_acct_balance:
    // tests/artifacts/StateOps/contract.py:25-26
    // @arc4.abimethod()
    // def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:27
    // value, funded = op.AcctParamsGet.acct_balance(a)
    frame_dig -1
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:28
    // value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
    acct_params_get AcctBalance
    // tests/artifacts/StateOps/contract.py:29
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:30
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:31
    // assert value == a.balance, "expected Account balance to match"
    frame_dig -1
    acct_params_get AcctBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account balance to match
    // tests/artifacts/StateOps/contract.py:32
    // assert value == algopy.op.balance(a), "expected op.balance to match"
    frame_dig -1
    balance
    dig 1
    ==
    assert // expected op.balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:33-35
    // assert value == algopy.op.balance(
    //     _get_1st_ref_index()
    // ), "expected op.balance by index to match"
    balance
    dig 1
    ==
    assert // expected op.balance by index to match
    // tests/artifacts/StateOps/contract.py:36
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_min_balance(a: bytes) -> uint64:
verify_acct_min_balance:
    // tests/artifacts/StateOps/contract.py:38-39
    // @arc4.abimethod()
    // def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:40
    // value, funded = op.AcctParamsGet.acct_min_balance(a)
    frame_dig -1
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:41
    // value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
    acct_params_get AcctMinBalance
    // tests/artifacts/StateOps/contract.py:42
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:43
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:44
    // assert value == a.min_balance, "expected Account min_balance to match"
    frame_dig -1
    acct_params_get AcctMinBalance
    assert // account funded
    dig 1
    ==
    assert // expected Account min_balance to match
    // tests/artifacts/StateOps/contract.py:45
    // assert value == algopy.op.min_balance(a), "expected op.min_balance to match"
    frame_dig -1
    min_balance
    dig 1
    ==
    assert // expected op.min_balance to match
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:46-48
    // assert value == algopy.op.min_balance(
    //     _get_1st_ref_index()
    // ), "expected op.min_balance by index to match"
    min_balance
    dig 1
    ==
    assert // expected op.min_balance by index to match
    // tests/artifacts/StateOps/contract.py:49
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_auth_addr(a: bytes) -> bytes:
verify_acct_auth_addr:
    // tests/artifacts/StateOps/contract.py:51-52
    // @arc4.abimethod()
    // def verify_acct_auth_addr(self, a: algopy.Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:53
    // value, funded = op.AcctParamsGet.acct_auth_addr(a)
    frame_dig -1
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:54
    // value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
    acct_params_get AcctAuthAddr
    // tests/artifacts/StateOps/contract.py:55
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:56
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:57
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_uint(a: bytes) -> uint64:
verify_acct_total_num_uint:
    // tests/artifacts/StateOps/contract.py:59-60
    // @arc4.abimethod()
    // def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:61
    // value, funded = op.AcctParamsGet.acct_total_num_uint(a)
    frame_dig -1
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:62
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
    acct_params_get AcctTotalNumUint
    // tests/artifacts/StateOps/contract.py:63
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:64
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:65
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_num_byte_slice(a: bytes) -> uint64:
verify_acct_total_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:69
    // value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
    frame_dig -1
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:70-72
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_byte_slice(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalNumByteSlice
    // tests/artifacts/StateOps/contract.py:73
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:74
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:75
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_extra_app_pages(a: bytes) -> uint64:
verify_acct_total_extra_app_pages:
    // tests/artifacts/StateOps/contract.py:77-78
    // @arc4.abimethod()
    // def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:79
    // value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
    frame_dig -1
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:80-82
    // value_index, funded_index = op.AcctParamsGet.acct_total_extra_app_pages(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalExtraAppPages
    // tests/artifacts/StateOps/contract.py:83
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:84
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:85
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_created(a: bytes) -> uint64:
verify_acct_total_apps_created:
    // tests/artifacts/StateOps/contract.py:87-88
    // @arc4.abimethod()
    // def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:89
    // value, funded = op.AcctParamsGet.acct_total_apps_created(a)
    frame_dig -1
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:90
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
    acct_params_get AcctTotalAppsCreated
    // tests/artifacts/StateOps/contract.py:91
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:92
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:93
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_apps_opted_in(a: bytes) -> uint64:
verify_acct_total_apps_opted_in:
    // tests/artifacts/StateOps/contract.py:95-96
    // @arc4.abimethod()
    // def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:97
    // value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
    frame_dig -1
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:98
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
    acct_params_get AcctTotalAppsOptedIn
    // tests/artifacts/StateOps/contract.py:99
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:100
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:101
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets_created(a: bytes) -> uint64:
verify_acct_total_assets_created:
    // tests/artifacts/StateOps/contract.py:103-104
    // @arc4.abimethod()
    // def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:105
    // value, funded = op.AcctParamsGet.acct_total_assets_created(a)
    frame_dig -1
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:106-108
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets_created(
    //     _get_1st_ref_index()
    // )
    acct_params_get AcctTotalAssetsCreated
    // tests/artifacts/StateOps/contract.py:109
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:110
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:111
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_assets(a: bytes) -> uint64:
verify_acct_total_assets:
    // tests/artifacts/StateOps/contract.py:113-114
    // @arc4.abimethod()
    // def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:115
    // value, funded = op.AcctParamsGet.acct_total_assets(a)
    frame_dig -1
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:116
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
    acct_params_get AcctTotalAssets
    // tests/artifacts/StateOps/contract.py:117
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:118
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:119
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_boxes(a: bytes) -> uint64:
verify_acct_total_boxes:
    // tests/artifacts/StateOps/contract.py:121-122
    // @arc4.abimethod()
    // def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:123
    // value, funded = op.AcctParamsGet.acct_total_boxes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:124
    // value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxes
    // tests/artifacts/StateOps/contract.py:125
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:126
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:127
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_total_box_bytes(a: bytes) -> uint64:
verify_acct_total_box_bytes:
    // tests/artifacts/StateOps/contract.py:129-130
    // @arc4.abimethod()
    // def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:131
    // value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
    frame_dig -1
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:132
    // value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
    acct_params_get AcctTotalBoxBytes
    // tests/artifacts/StateOps/contract.py:133
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:134
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:135
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_incentive_eligible(a: bytes) -> uint64:
verify_acct_incentive_eligible:
    // tests/artifacts/StateOps/contract.py:137-138
    // @arc4.abimethod()
    // def verify_acct_incentive_eligible(self, a: algopy.Account) -> bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:139
    // value, funded = op.AcctParamsGet.acct_incentive_eligible(a)
    frame_dig -1
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:140
    // value_index, funded_index = op.AcctParamsGet.acct_incentive_eligible(_get_1st_ref_index())
    acct_params_get AcctIncentiveEligible
    // tests/artifacts/StateOps/contract.py:141
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:142
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:143
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_heartbeat(a: bytes) -> uint64:
verify_acct_last_heartbeat:
    // tests/artifacts/StateOps/contract.py:145-146
    // @arc4.abimethod()
    // def verify_acct_last_heartbeat(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:147
    // value, funded = op.AcctParamsGet.acct_last_heartbeat(a)
    frame_dig -1
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:148
    // value_index, funded_index = op.AcctParamsGet.acct_last_heartbeat(_get_1st_ref_index())
    acct_params_get AcctLastHeartbeat
    // tests/artifacts/StateOps/contract.py:149
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:150
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:151
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_last_proposed(a: bytes) -> uint64:
verify_acct_last_proposed:
    // tests/artifacts/StateOps/contract.py:153-154
    // @arc4.abimethod()
    // def verify_acct_last_proposed(self, a: algopy.Account) -> algopy.UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:155
    // value, funded = op.AcctParamsGet.acct_last_proposed(a)
    frame_dig -1
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:156
    // value_index, funded_index = op.AcctParamsGet.acct_last_proposed(_get_1st_ref_index())
    acct_params_get AcctLastProposed
    // tests/artifacts/StateOps/contract.py:157
    // assert value == value_index, "expected value by index to match"
    dig 3
    uncover 2
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:158
    // assert funded == funded_index, "expected funded by index to match"
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:159
    // return value
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDExCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
@@ -503,8 +503,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalContract.arc56.json b/tests/artifacts/StateOps/data/StateAppGlobalContract.arc56.json
index 658db95c..81a0ae23 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAppGlobalContract.arc56.json
@@ -263,8 +263,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal b/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal
index d0b3536e..9bf68408 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal
@@ -52,7 +52,11 @@ main:
     // tests/artifacts/StateOps/contract.py:442
     // self.global_arc4_bytes_explicit = algopy.arc4.DynamicBytes(b"dummy_arc4_bytes")
     pushbytes "global_arc4_bytes_explicit"
+    // tests/artifacts/StateOps/contract.py:440
+    // algopy.arc4.DynamicBytes(b"dummy_arc4_bytes"), key="global_arc4_bytes"
     bytec_1 // 0x001064756d6d795f617263345f6279746573
+    // tests/artifacts/StateOps/contract.py:442
+    // self.global_arc4_bytes_explicit = algopy.arc4.DynamicBytes(b"dummy_arc4_bytes")
     app_global_put
 
 main_after_if_else@2:
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json b/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json
index ecc69368..6106952a 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json
@@ -1,7 +1,7 @@
 {
     "hints": {},
     "source": {
-        "approval": "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",
+        "approval": "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",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc56.json b/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc56.json
index 1936a8a4..62a42258 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc56.json
@@ -84,7 +84,7 @@
         }
     },
     "source": {
-        "approval": "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",
+        "approval": "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",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
@@ -95,8 +95,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAppLocalContract.arc56.json b/tests/artifacts/StateOps/data/StateAppLocalContract.arc56.json
index 9589c95b..f9cd3c85 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAppLocalContract.arc56.json
@@ -341,8 +341,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAppLocalExContract.arc56.json b/tests/artifacts/StateOps/data/StateAppLocalExContract.arc56.json
index d06ea30e..d05fb1ee 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalExContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAppLocalExContract.arc56.json
@@ -109,8 +109,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAppParamsContract.arc56.json b/tests/artifacts/StateOps/data/StateAppParamsContract.arc56.json
index ef76bcd4..23d0670a 100644
--- a/tests/artifacts/StateOps/data/StateAppParamsContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAppParamsContract.arc56.json
@@ -310,8 +310,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc56.json b/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc56.json
index c41aa29b..e58901ac 100644
--- a/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc56.json
@@ -129,8 +129,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/data/StateAssetParamsContract.arc56.json b/tests/artifacts/StateOps/data/StateAssetParamsContract.arc56.json
index e8aadf14..e075a58d 100644
--- a/tests/artifacts/StateOps/data/StateAssetParamsContract.arc56.json
+++ b/tests/artifacts/StateOps/data/StateAssetParamsContract.arc56.json
@@ -385,8 +385,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/artifacts/Tuples/data/TuplesContract.arc56.json b/tests/artifacts/Tuples/data/TuplesContract.arc56.json
index 4153bea5..911ea3c2 100644
--- a/tests/artifacts/Tuples/data/TuplesContract.arc56.json
+++ b/tests/artifacts/Tuples/data/TuplesContract.arc56.json
@@ -93,8 +93,8 @@
         "compiler": "puya",
         "compilerVersion": {
             "major": 4,
-            "minor": 8,
-            "patch": 1
+            "minor": 10,
+            "patch": 0
         }
     },
     "events": [],
diff --git a/tests/models/test_box.py b/tests/models/test_box.py
index ac86bac6..6fb6f8fb 100644
--- a/tests/models/test_box.py
+++ b/tests/models/test_box.py
@@ -10,6 +10,13 @@
 from _algopy_testing.models.application import Application
 from _algopy_testing.models.asset import Asset
 from _algopy_testing.op.pure import itob
+from _algopy_testing.primitives.array import (
+    Array,
+    FixedArray,
+    ImmutableArray,
+    ImmutableFixedArray,
+    Struct,
+)
 from _algopy_testing.primitives.biguint import BigUInt
 from _algopy_testing.primitives.bytes import Bytes
 from _algopy_testing.primitives.string import String
@@ -367,3 +374,86 @@ def test_enums_in_boxes() -> None:
         # Assert
         assert context.ledger.get_box(contract, b"oca") == itob(oca.native)
         assert context.ledger.get_box(contract, b"txn") == itob(txn.native)
+
+
+class Swapped2(Struct):
+    a: Array[UInt64]
+    b: Array[UInt64]
+
+
+def test_arrays_and_struct_in_boxes(context: AlgopyTestContext) -> None:  # noqa: ARG001
+    # Array
+    arr1 = Array([UInt64(1), UInt64(2), UInt64(3)])
+    arr2 = Array([UInt64(4), UInt64(5), UInt64(6)])
+    nested_arr1 = Array([arr1, arr2])
+    box1 = Box(Array[Array[UInt64]], key=b"test_array_1")
+    box1.value = nested_arr1
+    _op_box_content, op_box_exists = algopy.op.Box.get(b"test_array_1")
+    op_box_length, _ = algopy.op.Box.length(b"test_array_1")
+    assert op_box_exists
+    assert box1.length == op_box_length
+
+    box1.value[0][1] = UInt64(20)
+    assert list(box1.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
+
+    # FixedArray
+    arr3 = FixedArray[UInt64, typing.Literal[3]]([UInt64(1), UInt64(2), UInt64(3)])
+    arr4 = FixedArray[UInt64, typing.Literal[3]]([UInt64(4), UInt64(5), UInt64(6)])
+    nested_arr2 = FixedArray[FixedArray[UInt64, typing.Literal[3]], typing.Literal[2]](
+        [arr3, arr4]
+    )
+    box2 = Box(
+        FixedArray[FixedArray[UInt64, typing.Literal[3]], typing.Literal[2]], key=b"test_array_2"
+    )
+    box2.value = nested_arr2
+    _op_box_content, op_box_exists = algopy.op.Box.get(b"test_array_2")
+    op_box_length, _ = algopy.op.Box.length(b"test_array_2")
+    assert op_box_exists
+    assert box2.length == op_box_length
+
+    box2.value[0][1] = UInt64(20)
+    assert list(box2.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
+
+    # ImmutableArray
+    nested_arr3 = ImmutableArray[Array[UInt64]](arr1, arr2)
+    box3 = Box(ImmutableArray[Array[UInt64]], key=b"test_array_3")
+    box3.value = nested_arr3
+    _op_box_content, op_box_exists = algopy.op.Box.get(b"test_array_3")
+    op_box_length, _ = algopy.op.Box.length(b"test_array_3")
+    assert op_box_exists
+    assert box3.length == op_box_length
+
+    box3.value[0][1] = UInt64(20)
+    assert list(box3.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
+
+    # ImmutableFixedArray
+    nested_arr4 = ImmutableFixedArray[FixedArray[UInt64, typing.Literal[3]], typing.Literal[2]](
+        [arr3, arr4]
+    )
+    box4 = Box(
+        ImmutableFixedArray[FixedArray[UInt64, typing.Literal[3]], typing.Literal[2]],
+        key=b"test_array_4",
+    )
+    box4.value = nested_arr4
+    _op_box_content, op_box_exists = algopy.op.Box.get(b"test_array_4")
+    op_box_length, _ = algopy.op.Box.length(b"test_array_4")
+    assert op_box_exists
+    assert box4.length == op_box_length
+
+    box4.value[0][1] = UInt64(20)
+    assert list(box4.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
+
+    # Struct
+    struct1 = Swapped2(arr1, arr2)
+    box5 = Box(
+        Swapped2,
+        key=b"test_struct_1",
+    )
+    box5.value = struct1
+    _op_box_content, op_box_exists = algopy.op.Box.get(b"test_struct_1")
+    op_box_length, _ = algopy.op.Box.length(b"test_struct_1")
+    assert op_box_exists
+    assert box5.length == op_box_length
+
+    box5.value.a[1] = UInt64(20)
+    assert list(box5.value.a) == [UInt64(1), UInt64(20), UInt64(3)]
diff --git a/tests/test_array.py b/tests/test_array.py
index fb7dc0b8..ce468607 100644
--- a/tests/test_array.py
+++ b/tests/test_array.py
@@ -2,10 +2,16 @@
 
 import algosdk
 import pytest
+from _algopy_testing.constants import MAX_UINT512
 from algopy import ImmutableArray, String, UInt64, arc4
 from algopy_testing import AlgopyTestContext, algopy_testing_context
 
-from tests.artifacts.Arrays.immutable import ImmutableArrayContract, MyDynamicSizedTuple, MyTuple
+from tests.artifacts.Arrays.immutable import (
+    ImmutableArrayContract,
+    MyDynamicSizedTuple,
+    MyStruct,
+    MyTuple,
+)
 from tests.artifacts.Arrays.static_size import More, StaticSizeContract
 from tests.artifacts.Arrays.uint64 import Contract as UInt64Contract
 
@@ -32,6 +38,9 @@ def test_array_uint64(context: AlgopyTestContext) -> None:  # noqa: ARG001
 
     contract.test_quicksort()
 
+    contract.test_array_assignment_maximum_cursage()
+    contract.test_unobserved_write()
+
 
 def test_array_static_size(context: AlgopyTestContext) -> None:
     contract = StaticSizeContract()
@@ -46,11 +55,11 @@ def test_array_static_size(context: AlgopyTestContext) -> None:
 
     assert context.ledger.box_exists(contract, b"a")
     assert context.ledger.get_box(contract, b"a") == _get_arc4_bytes(
-        "(uint64,uint64,(uint64,uint64,address,(uint64,uint64)))[]",
+        "(uint64,uint64,(uint64,uint64,address,(uint64,uint64),uint512))[]",
         [
-            (0, 0, (5, 1, sender, (2, 1))),
-            (x1, y1, (5, 2, sender, (3, 4))),
-            (x2, y2, (5, 3, sender, (4, 9))),
+            (0, 0, (5, 1, sender, (2, 1), 1)),
+            (x1, y1, (5, 2, sender, (3, 4), 2)),
+            (x2, y2, (5, 3, sender, (4, 9), 3)),
         ],
     )
 
@@ -76,6 +85,9 @@ def test_array_static_size(context: AlgopyTestContext) -> None:
         More(arc4.UInt64(3), arc4.UInt64(4)),
     ]
 
+    arc4_bool = contract.test_arc4_bool()
+    assert list(arc4_bool) == [arc4.Bool(False), arc4.Bool(True)]
+
 
 def test_immutable_array(context: AlgopyTestContext) -> None:
     app = ImmutableArrayContract()
@@ -85,6 +97,11 @@ def test_immutable_array(context: AlgopyTestContext) -> None:
         "uint64[]", [42, 0, 23, 2, *range(10), 44]
     )
 
+    app.test_biguint_array()
+    assert context.ledger.get_box(app, b"biguint") == _get_arc4_bytes(
+        "uint512[]", [0, 0, 1, 2, 3, 4, MAX_UINT512 - 1, MAX_UINT512]
+    )
+
     app.test_fixed_size_tuple_array()
     assert context.ledger.get_global_state(app, b"c") == _get_arc4_bytes(
         "(uint64,uint64)[]", [(i + 1, i + 2) for i in range(4)]
@@ -148,6 +165,26 @@ def test_immutable_array(context: AlgopyTestContext) -> None:
     )
     assert list(response) == [one, two, three, four]
 
+    immutable_arc4_input = ImmutableArray(
+        MyStruct(arc4.UInt64(1), arc4.UInt64(2)),
+        MyStruct(arc4.UInt64(3), arc4.UInt64(4)),
+        MyStruct(arc4.UInt64(5), arc4.UInt64(6)),
+    )
+    immutable_arc4_result = app.test_immutable_arc4(immutable_arc4_input)
+    assert list(immutable_arc4_result) == [
+        MyStruct(arc4.UInt64(1), arc4.UInt64(2)),
+        MyStruct(arc4.UInt64(3), arc4.UInt64(4)),
+        MyStruct(arc4.UInt64(1), arc4.UInt64(2)),
+    ]
+    assert list(immutable_arc4_input) == [
+        MyStruct(arc4.UInt64(1), arc4.UInt64(2)),
+        MyStruct(arc4.UInt64(3), arc4.UInt64(4)),
+        MyStruct(arc4.UInt64(5), arc4.UInt64(6)),
+    ]
+
+    imm_fixed_arr = app.test_imm_fixed_arr()
+    assert len(imm_fixed_arr) == 3
+
 
 _EXPECTED_LENGTH_20 = [False, False, True, *(False,) * 17]
 
diff --git a/tests/utilities/test_size_of.py b/tests/utilities/test_size_of.py
index ef0e94a4..36d9f6d1 100644
--- a/tests/utilities/test_size_of.py
+++ b/tests/utilities/test_size_of.py
@@ -1,10 +1,24 @@
 import typing
 
 import pytest
-from algopy import Account, Application, Asset, Bytes, String, UInt64, arc4, size_of
+from algopy import (
+    Account,
+    Application,
+    Array,
+    Asset,
+    Bytes,
+    FixedArray,
+    ImmutableArray,
+    ImmutableFixedArray,
+    String,
+    Struct,
+    UInt64,
+    arc4,
+    size_of,
+)
 
 
-class Swapped(arc4.Struct):
+class SwappedArc4(arc4.Struct):
     a: arc4.UInt64
     b: arc4.Bool
     c: arc4.Tuple[arc4.UInt64, arc4.Bool, arc4.Bool]
@@ -12,10 +26,19 @@ class Swapped(arc4.Struct):
     e: arc4.Tuple[arc4.UInt64, arc4.StaticArray[arc4.UInt64, typing.Literal[3]]]
 
 
+class Swapped(Struct):
+    a: UInt64
+    b: bool
+    c: tuple[UInt64, bool, bool]
+    d: FixedArray[bool, typing.Literal[10]]
+    e: tuple[UInt64, ImmutableFixedArray[UInt64, typing.Literal[3]]]
+
+
 class WhatsMySize(typing.NamedTuple):
     foo: UInt64
     bar: bool
-    baz: Swapped
+    bax: Swapped
+    baz: SwappedArc4
 
 
 class MyTuple(typing.NamedTuple):
@@ -45,10 +68,13 @@ def test_size_of() -> None:
     assert size_of(tuple[arc4.UInt64, UInt64, bool, arc4.Bool]) == 17
     assert size_of(arc4.Tuple[arc4.UInt64, arc4.Bool, arc4.Bool] == 9)
     assert size_of(MyTuple) == 9
-    assert size_of(WhatsMySize) == 61
+    assert size_of(SwappedArc4) == 52
+    assert size_of(Swapped) == 52
+    assert size_of(WhatsMySize) == 113
     assert size_of(arc4.StaticArray[arc4.Byte, typing.Literal[7]]) == 7
     assert size_of(arc4.StaticArray(arc4.Byte(), arc4.Byte())) == 2
-    assert size_of(Swapped) == 52
+    assert size_of(FixedArray[bool, typing.Literal[10]]) == 2
+    assert size_of(ImmutableFixedArray[bool, typing.Literal[10]]) == 2
 
 
 @pytest.mark.parametrize(
@@ -58,6 +84,8 @@ def test_size_of() -> None:
         tuple[arc4.DynamicBytes, Bytes],
         arc4.Tuple[arc4.UInt64, arc4.String],
         MyDynamicSizedTuple,
+        Array[UInt64],
+        ImmutableArray[UInt64],
     ],
 )
 def test_size_of_dynamic(typ: type) -> None:

From 1436b66a3bbbb07ab6b33f81c0bc8f1d0bd9d1b7 Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Mon, 4 Aug 2025 17:10:52 +0700
Subject: [PATCH 2/8] refactor: addressing review feedback

---
 src/_algopy_testing/primitives/array.py | 39 ++++++++++---------------
 tests/models/test_box.py                | 20 +++++--------
 2 files changed, 24 insertions(+), 35 deletions(-)

diff --git a/src/_algopy_testing/primitives/array.py b/src/_algopy_testing/primitives/array.py
index 40b31fc8..0835eceb 100644
--- a/src/_algopy_testing/primitives/array.py
+++ b/src/_algopy_testing/primitives/array.py
@@ -45,7 +45,6 @@ def __getitem__(cls, item: tuple[type[_TArrayItem], type[_TArrayLength]]) -> typ
 
 class ImmutableFixedArray(
     Serializable,
-    MutableBytes,
     typing.Generic[_TArrayItem, _TArrayLength],
     metaclass=_ImmutableFixedArrayMeta,
 ):
@@ -58,8 +57,8 @@ def __new__(cls, values: Iterable[_TArrayItem]) -> typing.Self:
         try:
             assert cls._element_type
         except AttributeError:
+            items = list(values)
             try:
-                items = list(values)
                 item = items[0]
             except IndexError:
                 raise TypeError("array must have an item type") from None
@@ -106,12 +105,11 @@ def __reversed__(self) -> typing.Iterator[_TArrayItem]:
     def length(self) -> UInt64:
         return UInt64(len(self._items))
 
-    def __len__(self) -> UInt64:
-        return self.length
+    def __len__(self) -> int:
+        return len(self._items)
 
     def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
-        value = self._items[index]
-        return set_item_on_mutate(self, index, value)
+        return self._items[index]
 
     def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
         self._items[int(index)] = value
@@ -180,11 +178,9 @@ class FixedArray(
     _length: int
 
     def __new__(cls, values: Iterable[_TArrayItem]) -> typing.Self:
-        try:
-            assert cls._element_type
-        except AttributeError:
+        if not hasattr(cls, "_element_type"):
+            items = list(values)
             try:
-                items = list(values)
                 item = items[0]
             except IndexError:
                 raise TypeError("array must have an item type") from None
@@ -206,7 +202,7 @@ def __init__(self, values: Iterable[_TArrayItem]) -> None:
 
     @classmethod
     def full(cls, item: _TArrayItem) -> typing.Self:
-        return cls(item for _ in range(cls._length))
+        return cls([item] * cls._length)
 
     def __iter__(self) -> typing.Iterator[_TArrayItem]:
         return iter(self._items)
@@ -218,8 +214,8 @@ def __reversed__(self) -> typing.Iterator[_TArrayItem]:
     def length(self) -> UInt64:
         return UInt64(len(self._items))
 
-    def __len__(self) -> UInt64:
-        return self.length
+    def __len__(self) -> int:
+        return len(self._items)
 
     def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
         value = self._items[index]
@@ -278,9 +274,7 @@ def __getitem__(cls, element_t: type) -> type:
         return c
 
 
-class ImmutableArray(
-    Serializable, MutableBytes, typing.Generic[_TArrayItem], metaclass=_ImmutableArrayMeta
-):
+class ImmutableArray(Serializable, typing.Generic[_TArrayItem], metaclass=_ImmutableArrayMeta):
     _element_type: typing.ClassVar[type]
 
     # ensure type is fully parameterized by looking up type from metaclass
@@ -316,12 +310,11 @@ def __reversed__(self) -> Iterator[_TArrayItem]:
     def length(self) -> UInt64:
         return UInt64(len(self._items))
 
-    def __len__(self) -> UInt64:
-        return self.length
+    def __len__(self) -> int:
+        return len(self._items)
 
     def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
-        value = self._items[index]
-        return set_item_on_mutate(self, index, value)
+        return self._items[index]
 
     def __setitem__(self, index: UInt64 | int, value: _TArrayItem) -> _TArrayItem:
         self._items[int(index)] = value
@@ -437,8 +430,8 @@ def __new__(cls, values: Iterable[_TArrayItem]) -> typing.Self:
         try:
             assert cls._element_type
         except AttributeError:
+            items = list(values)
             try:
-                items = list(values)
                 item = items[0]
             except IndexError:
                 raise TypeError("array must have an item type") from None
@@ -464,8 +457,8 @@ def __reversed__(self) -> typing.Iterator[_TArrayItem]:
     def length(self) -> UInt64:
         return UInt64(len(self._items))
 
-    def __len__(self) -> UInt64:
-        return self.length
+    def __len__(self) -> int:
+        return len(self._items)
 
     def __getitem__(self, index: UInt64 | int) -> _TArrayItem:
         value = self._items[index]
diff --git a/tests/models/test_box.py b/tests/models/test_box.py
index 6fb6f8fb..0155b94a 100644
--- a/tests/models/test_box.py
+++ b/tests/models/test_box.py
@@ -415,23 +415,22 @@ def test_arrays_and_struct_in_boxes(context: AlgopyTestContext) -> None:  # noqa
     assert list(box2.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
 
     # ImmutableArray
-    nested_arr3 = ImmutableArray[Array[UInt64]](arr1, arr2)
-    box3 = Box(ImmutableArray[Array[UInt64]], key=b"test_array_3")
+    nested_arr3 = ImmutableArray[ImmutableArray[UInt64]](
+        ImmutableArray(*arr1), ImmutableArray(*arr2)
+    )
+    box3 = Box(ImmutableArray[ImmutableArray[UInt64]], key=b"test_array_3")
     box3.value = nested_arr3
     _op_box_content, op_box_exists = algopy.op.Box.get(b"test_array_3")
     op_box_length, _ = algopy.op.Box.length(b"test_array_3")
     assert op_box_exists
     assert box3.length == op_box_length
 
-    box3.value[0][1] = UInt64(20)
-    assert list(box3.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
-
     # ImmutableFixedArray
-    nested_arr4 = ImmutableFixedArray[FixedArray[UInt64, typing.Literal[3]], typing.Literal[2]](
-        [arr3, arr4]
-    )
+    nested_arr4 = ImmutableFixedArray[
+        ImmutableFixedArray[UInt64, typing.Literal[3]], typing.Literal[2]
+    ]([ImmutableFixedArray(arr3), ImmutableFixedArray(arr4)])
     box4 = Box(
-        ImmutableFixedArray[FixedArray[UInt64, typing.Literal[3]], typing.Literal[2]],
+        ImmutableFixedArray[ImmutableFixedArray[UInt64, typing.Literal[3]], typing.Literal[2]],
         key=b"test_array_4",
     )
     box4.value = nested_arr4
@@ -440,9 +439,6 @@ def test_arrays_and_struct_in_boxes(context: AlgopyTestContext) -> None:  # noqa
     assert op_box_exists
     assert box4.length == op_box_length
 
-    box4.value[0][1] = UInt64(20)
-    assert list(box4.value[0]) == [UInt64(1), UInt64(20), UInt64(3)]
-
     # Struct
     struct1 = Swapped2(arr1, arr2)
     box5 = Box(

From 599b6b381a6dee12f5268c37bcde08e09eded4ec Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Tue, 5 Aug 2025 16:33:08 +0700
Subject: [PATCH 3/8] add resource encoding option with `value` as default

---
 .../context_helpers/txn_context.py            |   3 +-
 src/_algopy_testing/decorators/arc4.py        |  74 +++-
 tests/arc4/test_arc4_method_signature.py      | 103 +++++
 tests/artifacts/Arc4ABIMethod/contract.py     |  36 +-
 .../data/SignaturesContract.approval.teal     | 392 +++++++++++++-----
 .../data/SignaturesContract.arc32.json        |  54 ++-
 .../data/SignaturesContract.arc56.json        | 170 ++++++--
 tests/artifacts/StateOps/contract.py          |  30 +-
 8 files changed, 676 insertions(+), 186 deletions(-)

diff --git a/src/_algopy_testing/context_helpers/txn_context.py b/src/_algopy_testing/context_helpers/txn_context.py
index a86d91db..3e48a5ba 100644
--- a/src/_algopy_testing/context_helpers/txn_context.py
+++ b/src/_algopy_testing/context_helpers/txn_context.py
@@ -121,6 +121,7 @@ def defer_app_call(
                 arc4_signature=arc4_metadata.arc4_signature,
                 args=ordered_args,
                 allow_actions=allow_actions,
+                resource_encoding=arc4_metadata.resource_encoding,
             )
         # Handle bare methods
         else:
@@ -169,7 +170,7 @@ def create_group(
         new_group = TransactionGroup(
             txns=processed_gtxns,
             active_txn_index=active_txn_index,
-            active_txn_overrides=typing.cast(dict[str, typing.Any], active_txn_overrides),
+            active_txn_overrides=typing.cast("dict[str, typing.Any]", active_txn_overrides),
         )
         self._active_group = new_group
         try:
diff --git a/src/_algopy_testing/decorators/arc4.py b/src/_algopy_testing/decorators/arc4.py
index 20792faa..50215436 100644
--- a/src/_algopy_testing/decorators/arc4.py
+++ b/src/_algopy_testing/decorators/arc4.py
@@ -34,6 +34,8 @@
         ]
     )
 _CreateValues = typing.Literal["allow", "require", "disallow"]
+_ResourceEncoding = typing.Literal["index", "value"]
+_Direction = typing.Literal["input", "output"]
 ARC4_METADATA_ATTR = "arc4_metadata"
 
 
@@ -51,6 +53,7 @@ class MethodMetadata:
     create: _CreateValues
     allow_actions: Sequence[_AllowActions]
     arc4_signature: str | None = None
+    resource_encoding: _ResourceEncoding = "value"
 
     @property
     def is_create(self) -> bool:
@@ -145,6 +148,7 @@ def abimethod(  # noqa: PLR0913
     name: str | None = None,
     create: _CreateValues = "disallow",
     allow_actions: Sequence[_AllowActions] = ("NoOp",),
+    resource_encoding: _ResourceEncoding = "value",
     readonly: bool = False,
     default_args: Mapping[str, str | object] | None = None,
 ) -> Callable[[Callable[_P, _R]], Callable[_P, _R]] | Callable[_P, _R]:
@@ -160,13 +164,15 @@ def abimethod(  # noqa: PLR0913
             allow_actions=allow_actions,
             readonly=readonly,
             default_args=default_args,
+            resource_encoding=resource_encoding,
         )
 
     arc4_name = name or fn.__name__
     metadata = MethodMetadata(
         create=create,
         allow_actions=allow_actions,
-        arc4_signature=_generate_arc4_signature_from_fn(fn, arc4_name),
+        arc4_signature=_generate_arc4_signature_from_fn(fn, arc4_name, resource_encoding),
+        resource_encoding=resource_encoding,
     )
     set_arc4_metadata(fn, metadata)
 
@@ -187,6 +193,7 @@ def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
             arc4_signature=metadata.arc4_signature,
             args=ordered_args,
             allow_actions=allow_actions,
+            resource_encoding=metadata.resource_encoding,
         )
         with context.txn._maybe_implicit_txn_group(txns):
             check_routing_conditions(app_id, metadata)
@@ -204,6 +211,7 @@ def create_abimethod_txns(
     arc4_signature: str,
     args: Sequence[object],
     allow_actions: Sequence[_AllowActions],
+    resource_encoding: _ResourceEncoding,
 ) -> list[algopy.gtxn.TransactionBase]:
     contract_app = lazy_context.ledger.get_app(app_id)
     txn_fields = get_active_txn_fields(contract_app, allow_actions)
@@ -215,6 +223,7 @@ def create_abimethod_txns(
         method_selector=method_selector,
         sender=txn_fields["sender"],
         app=contract_app,
+        resource_encoding=resource_encoding,
     )
     txn_fields.setdefault("accounts", txn_arrays.accounts)
     txn_fields.setdefault("assets", txn_arrays.assets)
@@ -273,11 +282,12 @@ class _TxnArrays:
     app_args: list[algopy.Bytes]
 
 
-def _extract_arrays_from_args(
+def _extract_arrays_from_args(  # noqa: PLR0912
     args: Sequence[object],
     method_selector: algopy.Bytes,
     app: algopy.Application,
     sender: algopy.Account,
+    resource_encoding: _ResourceEncoding,
 ) -> _TxnArrays:
     from _algopy_testing.serialize import native_to_arc4
 
@@ -291,14 +301,23 @@ def _extract_arrays_from_args(
             case _algopy_testing.gtxn.TransactionBase() as txn:
                 txns.append(txn)
             case _algopy_testing.Account() as acc:
-                app_args.append(_algopy_testing.arc4.UInt8(len(accounts)))
-                accounts.append(acc)
+                if resource_encoding == "index":
+                    app_args.append(_algopy_testing.arc4.UInt8(len(accounts)))
+                    accounts.append(acc)
+                else:
+                    app_args.append(native_to_arc4(acc))
             case _algopy_testing.Asset() as asset:
-                app_args.append(_algopy_testing.arc4.UInt8(len(assets)))
-                assets.append(asset)
+                if resource_encoding == "index":
+                    app_args.append(_algopy_testing.arc4.UInt8(len(assets)))
+                    assets.append(asset)
+                else:
+                    app_args.append(native_to_arc4(asset.id))
             case _algopy_testing.Application() as arg_app:
-                app_args.append(_algopy_testing.arc4.UInt8(len(apps)))
-                apps.append(arg_app)
+                if resource_encoding == "index":
+                    app_args.append(_algopy_testing.arc4.UInt8(len(apps)))
+                    apps.append(arg_app)
+                else:
+                    app_args.append(native_to_arc4(arg_app.id))
             case _ as maybe_native:
                 app_args.append(native_to_arc4(maybe_native))
     if len(app_args) > 15:
@@ -313,18 +332,29 @@ def _extract_arrays_from_args(
     )
 
 
-def _generate_arc4_signature_from_fn(fn: typing.Callable[_P, _R], arc4_name: str) -> str:
+def _generate_arc4_signature_from_fn(
+    fn: typing.Callable[_P, _R], arc4_name: str, resource_encoding: _ResourceEncoding
+) -> str:
     annotations = inspect.get_annotations(fn, eval_str=True).copy()
-    returns = algosdk.abi.Returns(_type_to_arc4(annotations.pop("return")))
+    returns = algosdk.abi.Returns(
+        _type_to_arc4(annotations.pop("return"), resource_encoding, "output")
+    )
     method = algosdk.abi.Method(
         name=arc4_name,
-        args=[algosdk.abi.Argument(_type_to_arc4(a)) for a in annotations.values()],
+        args=[
+            algosdk.abi.Argument(_type_to_arc4(a, resource_encoding, "input"))
+            for a in annotations.values()
+        ],
         returns=returns,
     )
     return method.get_signature()
 
 
-def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa: PLR0911, PLR0912
+def _type_to_arc4(  # noqa: PLR0912 PLR0911
+    annotation: types.GenericAlias | type | None,
+    resource_encoding: _ResourceEncoding,
+    direction: _Direction,
+) -> str:
     from _algopy_testing.arc4 import _ABIEncoded
     from _algopy_testing.gtxn import Transaction, TransactionBase
     from _algopy_testing.models import Account, Application, Asset
@@ -340,7 +370,9 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
         return "void"
 
     if isinstance(annotation, types.GenericAlias) and typing.get_origin(annotation) is tuple:
-        tuple_args = [_type_to_arc4(a) for a in typing.get_args(annotation)]
+        tuple_args = [
+            _type_to_arc4(a, resource_encoding, direction) for a in typing.get_args(annotation)
+        ]
         return f"({','.join(tuple_args)})"
 
     if not isinstance(annotation, type):
@@ -350,11 +382,11 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
         annotation, Struct
     ):
         tuple_fields = list(inspect.get_annotations(annotation).values())
-        tuple_args = [_type_to_arc4(a) for a in tuple_fields]
+        tuple_args = [_type_to_arc4(a, resource_encoding, direction) for a in tuple_fields]
         return f"({','.join(tuple_args)})"
 
     if issubclass(annotation, Array | FixedArray | ImmutableArray | ImmutableFixedArray):
-        return f"{_type_to_arc4(annotation._element_type)}[]"
+        return f"{_type_to_arc4(annotation._element_type, resource_encoding, direction)}[]"
     # arc4 types
     if issubclass(annotation, _ABIEncoded):
         return annotation._type_info.arc4_name
@@ -365,11 +397,17 @@ def _type_to_arc4(annotation: types.GenericAlias | type | None) -> str:  # noqa:
         return annotation.type_enum.txn_name
     # reference types
     if issubclass(annotation, Account):
-        return "account"
+        if resource_encoding == "index" and direction == "input":
+            return "account"
+        return "address"
     if issubclass(annotation, Asset):
-        return "asset"
+        if resource_encoding == "index" and direction == "input":
+            return "asset"
+        return "uint64"
     if issubclass(annotation, Application):
-        return "application"
+        if resource_encoding == "index" and direction == "input":
+            return "application"
+        return "uint64"
     # native types
     if issubclass(annotation, UInt64):
         return "uint64"
diff --git a/tests/arc4/test_arc4_method_signature.py b/tests/arc4/test_arc4_method_signature.py
index 8b1f33c7..68d54178 100644
--- a/tests/arc4/test_arc4_method_signature.py
+++ b/tests/arc4/test_arc4_method_signature.py
@@ -369,3 +369,106 @@ def test_prepare_txns_with_complex(
     assert app_args[0] == arc4.arc4_signature(SignaturesContract.complex_sig)
     assert result[0].bytes == struct.another_struct.bytes
     assert result[1].bytes == struct.bytes
+
+
+def test_app_args_is_correct_with_index_resource_encoding(  # noqa: PLR0913
+    context: _algopy_testing.AlgopyTestContext,
+    localnet_creator_address: str,
+    other_app_id: int,
+    funded_account: str,
+    algorand: AlgorandClient,
+    get_avm_result: AVMInvoker,
+) -> None:
+    # arrange
+    contract = SignaturesContract()
+    contract.create()
+
+    asa_id = algorand.send.asset_create(
+        AssetCreateParams(
+            sender=localnet_creator_address,
+            total=123,
+        )
+    ).confirmation[
+        "asset-index"
+    ]  # type: ignore[call-overload]
+
+    # act
+    contract.echo_resource_by_index(
+        context.any.asset(total=algopy.UInt64(123)),
+        context.ledger.get_app(other_app_id),
+        context.ledger.get_account(funded_account),
+    )
+    result = get_avm_result(
+        "echo_resource_by_index",
+        asset=asa_id,
+        app=other_app_id,
+        acc=funded_account,
+    )
+
+    # assert
+    txn = context.txn.last_active
+    app_args = [txn.app_args(i) for i in range(int(txn.num_app_args))]
+    assert app_args == [
+        algosdk.abi.Method.from_signature(
+            "echo_resource_by_index(asset,application,account)(uint64,uint64,address)"
+        ).get_selector(),
+        b"\x00",
+        b"\x01",
+        b"\x01",
+    ]
+    assert app_args[0] == arc4.arc4_signature(SignaturesContract.echo_resource_by_index)
+
+    assert result == [asa_id, other_app_id, funded_account]
+
+
+def test_app_args_is_correct_with_value_resource_encoding(  # noqa: PLR0913
+    context: _algopy_testing.AlgopyTestContext,
+    localnet_creator_address: str,
+    other_app_id: int,
+    funded_account: str,
+    algorand: AlgorandClient,
+    get_avm_result: AVMInvoker,
+) -> None:
+    # arrange
+    contract = SignaturesContract()
+    contract.create()
+
+    asa_id = algorand.send.asset_create(
+        AssetCreateParams(
+            sender=localnet_creator_address,
+            total=123,
+        )
+    ).confirmation[
+        "asset-index"
+    ]  # type: ignore[call-overload]
+
+    asset = context.any.asset(asset_id=asa_id, total=algopy.UInt64(123))
+    app = context.ledger.get_app(other_app_id)
+    acc = context.ledger.get_account(funded_account)
+    # act
+    contract.echo_resource_by_value(
+        asset,
+        app,
+        acc,
+    )
+    result = get_avm_result(
+        "echo_resource_by_value",
+        asset=asa_id,
+        app=other_app_id,
+        acc=funded_account,
+    )
+
+    # assert
+    txn = context.txn.last_active
+    app_args = [txn.app_args(i) for i in range(int(txn.num_app_args))]
+    assert app_args == [
+        algosdk.abi.Method.from_signature(
+            "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)"
+        ).get_selector(),
+        asa_id.to_bytes(length=8),  # asset id as bytes
+        other_app_id.to_bytes(length=8),  # app id as bytes
+        context.ledger.get_account(funded_account).bytes,  # account address as bytes
+    ]
+    assert app_args[0] == arc4.arc4_signature(SignaturesContract.echo_resource_by_value)
+
+    assert result == [asset.id, app.id, acc]
diff --git a/tests/artifacts/Arc4ABIMethod/contract.py b/tests/artifacts/Arc4ABIMethod/contract.py
index a61848fd..f867065c 100644
--- a/tests/artifacts/Arc4ABIMethod/contract.py
+++ b/tests/artifacts/Arc4ABIMethod/contract.py
@@ -51,14 +51,14 @@ def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8A
         assert Txn.group_index == 1
         assert pay.amount == 123
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
         assert value
         assert arr
         assert asset.total == 123
         assert Txn.assets(0) == asset
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def with_app(
         self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
     ) -> None:
@@ -72,7 +72,7 @@ def with_app(
         assert app_txn.apps(1) == app
         assert Txn.applications(1) == app
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
         assert value
         assert arr
@@ -80,7 +80,7 @@ def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
         assert Txn.accounts(0) == Txn.sender
         assert Txn.accounts(1) == acc
 
-    @arc4.abimethod
+    @arc4.abimethod(resource_encoding="index")
     def complex_sig(
         self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
     ) -> tuple[MyStructAlias, MyStruct]:
@@ -102,3 +102,31 @@ def complex_sig(
         assert five[0] == 5
 
         return struct1.another_struct.copy(), struct1.copy()
+
+    @arc4.abimethod(
+        resource_encoding="index",
+    )
+    def echo_resource_by_index(
+        self, asset: Asset, app: Application, acc: Account
+    ) -> tuple[Asset, Application, Account]:
+        asset_idx = op.btoi(Txn.application_args(1))
+        assert asset == Txn.assets(asset_idx), "expected asset to be passed by index"
+        app_idx = op.btoi(Txn.application_args(2))
+        assert app == Txn.applications(app_idx), "expected application to be passed by index"
+        acc_idx = op.btoi(Txn.application_args(3))
+        assert acc == Txn.accounts(acc_idx), "expected account to be passed by index"
+        return asset, app, acc
+
+    @arc4.abimethod(
+        resource_encoding="value",
+    )
+    def echo_resource_by_value(
+        self, asset: Asset, app: Application, acc: Account
+    ) -> tuple[Asset, Application, Account]:
+        asset_id = op.btoi(Txn.application_args(1))
+        assert asset.id == asset_id, "expected asset to be passed by value"
+        app_id = op.btoi(Txn.application_args(2))
+        assert app.id == app_id, "expected application to be passed by value"
+        address = Txn.application_args(3)
+        assert acc.bytes == address, "expected account to be passed by value"
+        return asset, app, acc
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
index fd0e78b6..64ecfc1e 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
@@ -4,30 +4,106 @@
 // algopy.arc4.ARC4Contract.approval_program() -> uint64:
 main:
     intcblock 1 0 4 6
-    bytecblock 0x0000 0x0000000000000001 0x000132
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    bytecblock 0x0000 0x151f7c75 0x0000000000000001 0x000132
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txn NumAppArgs
-    bz main_after_if_else@14
-    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
+    bz main_after_if_else@16
+    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 0xd6c2ac7f 0x48142d5e // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))", method "echo_resource_by_index(asset,application,account)(uint64,uint64,address)", method "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)"
     txna ApplicationArgs 0
-    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10
+    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10 main_echo_resource_by_index_route@11 main_echo_resource_by_value_route@12
 
-main_after_if_else@14:
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+main_after_if_else@16:
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     intc_1 // 0
     return
 
+main_echo_resource_by_value_route@12:
+    // a/contract.py:120-122
+    // @arc4.abimethod(
+    //     resource_encoding="value",
+    // )
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    // a/contract.py:25
+    // class SignaturesContract(ARC4Contract):
+    txna ApplicationArgs 1
+    btoi
+    txna ApplicationArgs 2
+    btoi
+    txna ApplicationArgs 3
+    // a/contract.py:120-122
+    // @arc4.abimethod(
+    //     resource_encoding="value",
+    // )
+    callsub echo_resource_by_value
+    uncover 2
+    itob
+    uncover 2
+    itob
+    concat
+    swap
+    concat
+    bytec_1 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
+    return
+
+main_echo_resource_by_index_route@11:
+    // a/contract.py:106-108
+    // @arc4.abimethod(
+    //     resource_encoding="index",
+    // )
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    // a/contract.py:25
+    // class SignaturesContract(ARC4Contract):
+    txna ApplicationArgs 1
+    btoi
+    txnas Assets
+    txna ApplicationArgs 2
+    btoi
+    txnas Applications
+    txna ApplicationArgs 3
+    btoi
+    txnas Accounts
+    // a/contract.py:106-108
+    // @arc4.abimethod(
+    //     resource_encoding="index",
+    // )
+    callsub echo_resource_by_index
+    uncover 2
+    itob
+    uncover 2
+    itob
+    concat
+    swap
+    concat
+    bytec_1 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
+    return
+
 main_complex_sig_route@10:
-    // tests/artifacts/Arc4ABIMethod/contract.py:83
-    // @arc4.abimethod
+    // a/contract.py:83
+    // @arc4.abimethod(resource_encoding="index")
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txn GroupIndex
@@ -37,8 +113,8 @@ main_complex_sig_route@10:
     btoi
     txnas Accounts
     txna ApplicationArgs 3
-    // tests/artifacts/Arc4ABIMethod/contract.py:83
-    // @arc4.abimethod
+    // a/contract.py:83
+    // @arc4.abimethod(resource_encoding="index")
     callsub complex_sig
     dig 1
     len
@@ -53,7 +129,7 @@ main_complex_sig_route@10:
     concat
     swap
     concat
-    pushbytes 0x151f7c75
+    bytec_1 // 0x151f7c75
     swap
     concat
     log
@@ -61,35 +137,35 @@ main_complex_sig_route@10:
     return
 
 main_with_acc_route@9:
-    // tests/artifacts/Arc4ABIMethod/contract.py:75
-    // @arc4.abimethod
+    // a/contract.py:75
+    // @arc4.abimethod(resource_encoding="index")
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
     btoi
     txnas Accounts
     txna ApplicationArgs 3
-    // tests/artifacts/Arc4ABIMethod/contract.py:75
-    // @arc4.abimethod
+    // a/contract.py:75
+    // @arc4.abimethod(resource_encoding="index")
     callsub with_acc
     intc_0 // 1
     return
 
 main_with_app_route@8:
-    // tests/artifacts/Arc4ABIMethod/contract.py:61
-    // @arc4.abimethod
+    // a/contract.py:61
+    // @arc4.abimethod(resource_encoding="index")
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
@@ -97,42 +173,42 @@ main_with_app_route@8:
     txnas Applications
     txna ApplicationArgs 3
     txna ApplicationArgs 4
-    // tests/artifacts/Arc4ABIMethod/contract.py:61
-    // @arc4.abimethod
+    // a/contract.py:61
+    // @arc4.abimethod(resource_encoding="index")
     callsub with_app
     intc_0 // 1
     return
 
 main_with_asset_route@7:
-    // tests/artifacts/Arc4ABIMethod/contract.py:54
-    // @arc4.abimethod
+    // a/contract.py:54
+    // @arc4.abimethod(resource_encoding="index")
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
     btoi
     txnas Assets
     txna ApplicationArgs 3
-    // tests/artifacts/Arc4ABIMethod/contract.py:54
-    // @arc4.abimethod
+    // a/contract.py:54
+    // @arc4.abimethod(resource_encoding="index")
     callsub with_asset
     intc_0 // 1
     return
 
 main_with_txn_route@6:
-    // tests/artifacts/Arc4ABIMethod/contract.py:46
+    // a/contract.py:46
     // @arc4.abimethod
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txn GroupIndex
@@ -144,50 +220,50 @@ main_with_txn_route@6:
     ==
     assert // transaction type is pay
     txna ApplicationArgs 2
-    // tests/artifacts/Arc4ABIMethod/contract.py:46
+    // a/contract.py:46
     // @arc4.abimethod
     callsub with_txn
     intc_0 // 1
     return
 
 main_alias_route@5:
-    // tests/artifacts/Arc4ABIMethod/contract.py:41
+    // a/contract.py:41
     // @arc4.abimethod(name="alias")
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
-    // tests/artifacts/Arc4ABIMethod/contract.py:41
+    // a/contract.py:41
     // @arc4.abimethod(name="alias")
     callsub sink2
     intc_0 // 1
     return
 
 main_sink_route@4:
-    // tests/artifacts/Arc4ABIMethod/contract.py:36
+    // a/contract.py:36
     // @arc4.abimethod
     txn OnCompletion
     !
     assert // OnCompletion is not NoOp
     txn ApplicationID
     assert // can only call when not creating
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // a/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
     txna ApplicationArgs 2
-    // tests/artifacts/Arc4ABIMethod/contract.py:36
+    // a/contract.py:36
     // @arc4.abimethod
     callsub sink
     intc_0 // 1
     return
 
 main_create_route@3:
-    // tests/artifacts/Arc4ABIMethod/contract.py:26
+    // a/contract.py:26
     // @arc4.abimethod(create="require")
     txn OnCompletion
     !
@@ -200,38 +276,38 @@ main_create_route@3:
     return
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
+// test_cases.a.contract.SignaturesContract.create() -> void:
 create:
-    // tests/artifacts/Arc4ABIMethod/contract.py:28
+    // a/contract.py:28
     // app_txn = gtxn.ApplicationCallTransaction(0)
     intc_1 // 0
     gtxns TypeEnum
     intc_3 // appl
     ==
     assert // transaction type is appl
-    // tests/artifacts/Arc4ABIMethod/contract.py:29
+    // a/contract.py:29
     // assert op.Global.current_application_id != 0, "expected global to have app id"
     global CurrentApplicationID
     assert // expected global to have app id
-    // tests/artifacts/Arc4ABIMethod/contract.py:31
+    // a/contract.py:31
     // op.Global.current_application_address != op.Global.zero_address
     global CurrentApplicationAddress
     global ZeroAddress
     !=
-    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
+    // a/contract.py:30-32
     // assert (
     //     op.Global.current_application_address != op.Global.zero_address
     // ), "expected global to have app address"
     assert // expected global to have app address
-    // tests/artifacts/Arc4ABIMethod/contract.py:28
+    // a/contract.py:28
     // app_txn = gtxn.ApplicationCallTransaction(0)
     intc_1 // 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:33
+    // a/contract.py:33
     // assert app_txn.app_id == 0, "expected txn to have 0"
     gtxns ApplicationID
     !
     assert // expected txn to have 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:34
+    // a/contract.py:34
     // assert Txn.application_id == 0, "expected txn to have 0"
     txn ApplicationID
     !
@@ -239,19 +315,19 @@ create:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
+// test_cases.a.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
 sink:
-    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
+    // a/contract.py:36-37
     // @arc4.abimethod
     // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
     proto 2 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:38
+    // a/contract.py:38
     // assert value
     frame_dig -2
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:39
+    // a/contract.py:39
     // assert arr
     frame_dig -1
     bytec_0 // 0x0000
@@ -260,19 +336,19 @@ sink:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
+// test_cases.a.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
 sink2:
-    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
+    // a/contract.py:41-42
     // @arc4.abimethod(name="alias")
     // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
     proto 2 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:43
+    // a/contract.py:43
     // assert value
     frame_dig -2
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:44
+    // a/contract.py:44
     // assert arr
     frame_dig -1
     bytec_0 // 0x0000
@@ -281,37 +357,37 @@ sink2:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
+// test_cases.a.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
 with_txn:
-    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
+    // a/contract.py:46-47
     // @arc4.abimethod
     // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
     proto 3 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:48
+    // a/contract.py:48
     // assert value
     frame_dig -3
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:49
+    // a/contract.py:49
     // assert arr
     frame_dig -1
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:50
+    // a/contract.py:50
     // assert pay.group_index == 0
     frame_dig -2
     gtxns GroupIndex
     !
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:51
+    // a/contract.py:51
     // assert Txn.group_index == 1
     txn GroupIndex
     intc_0 // 1
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:52
+    // a/contract.py:52
     // assert pay.amount == 123
     frame_dig -2
     gtxns Amount
@@ -321,25 +397,25 @@ with_txn:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
+// test_cases.a.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
 with_asset:
-    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
-    // @arc4.abimethod
+    // a/contract.py:54-55
+    // @arc4.abimethod(resource_encoding="index")
     // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
     proto 3 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:56
+    // a/contract.py:56
     // assert value
     frame_dig -3
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:57
+    // a/contract.py:57
     // assert arr
     frame_dig -1
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:58
+    // a/contract.py:58
     // assert asset.total == 123
     frame_dig -2
     asset_params_get AssetTotal
@@ -347,7 +423,7 @@ with_asset:
     pushint 123 // 123
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:59
+    // a/contract.py:59
     // assert Txn.assets(0) == asset
     txna Assets 0
     frame_dig -2
@@ -356,34 +432,34 @@ with_asset:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
+// test_cases.a.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
 with_app:
-    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
-    // @arc4.abimethod
+    // a/contract.py:61-64
+    // @arc4.abimethod(resource_encoding="index")
     // def with_app(
     //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
     // ) -> None:
     proto 4 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:65
+    // a/contract.py:65
     // assert value
     frame_dig -4
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:66
+    // a/contract.py:66
     // assert arr
     frame_dig -1
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:67
+    // a/contract.py:67
     // assert app.id == app_id, "expected app id to match provided app id"
     frame_dig -3
     itob
     frame_dig -2
     b==
     assert // expected app id to match provided app id
-    // tests/artifacts/Arc4ABIMethod/contract.py:68
+    // a/contract.py:68
     // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
     frame_dig -3
     app_params_get AppCreator
@@ -391,7 +467,7 @@ with_app:
     global CreatorAddress
     ==
     assert // expected other app to have same creator
-    // tests/artifacts/Arc4ABIMethod/contract.py:69
+    // a/contract.py:69
     // app_txn = gtxn.ApplicationCallTransaction(0)
     intc_1 // 0
     gtxns TypeEnum
@@ -399,30 +475,30 @@ with_app:
     ==
     assert // transaction type is appl
     intc_1 // 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:70
+    // a/contract.py:70
     // assert app_txn.apps(0) == op.Global.current_application_id
     dup
     gtxnsas Applications
     global CurrentApplicationID
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:71
+    // a/contract.py:71
     // assert Txn.applications(0) == op.Global.current_application_id
     txna Applications 0
     global CurrentApplicationID
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:69
+    // a/contract.py:69
     // app_txn = gtxn.ApplicationCallTransaction(0)
     intc_1 // 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:72
+    // a/contract.py:72
     // assert app_txn.apps(1) == app
     intc_0 // 1
     gtxnsas Applications
     frame_dig -3
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:73
+    // a/contract.py:73
     // assert Txn.applications(1) == app
     txna Applications 1
     frame_dig -3
@@ -431,25 +507,25 @@ with_app:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
+// test_cases.a.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
 with_acc:
-    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
-    // @arc4.abimethod
+    // a/contract.py:75-76
+    // @arc4.abimethod(resource_encoding="index")
     // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
     proto 3 0
-    // tests/artifacts/Arc4ABIMethod/contract.py:77
+    // a/contract.py:77
     // assert value
     frame_dig -3
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:78
+    // a/contract.py:78
     // assert arr
     frame_dig -1
     bytec_0 // 0x0000
     !=
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:79
+    // a/contract.py:79
     // assert acc.balance == acc.min_balance + 1234
     frame_dig -2
     acct_params_get AcctBalance
@@ -461,13 +537,13 @@ with_acc:
     +
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:80
+    // a/contract.py:80
     // assert Txn.accounts(0) == Txn.sender
     txna Accounts 0
     txn Sender
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:81
+    // a/contract.py:81
     // assert Txn.accounts(1) == acc
     txna Accounts 1
     frame_dig -2
@@ -476,21 +552,21 @@ with_acc:
     retsub
 
 
-// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
+// test_cases.a.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
 complex_sig:
-    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
-    // @arc4.abimethod
+    // a/contract.py:83-86
+    // @arc4.abimethod(resource_encoding="index")
     // def complex_sig(
     //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
     // ) -> tuple[MyStructAlias, MyStruct]:
     proto 4 2
-    // tests/artifacts/Arc4ABIMethod/contract.py:87
+    // a/contract.py:87
     // assert Txn.num_app_args == 4
     txn NumAppArgs
     intc_2 // 4
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
+    // a/contract.py:88-89
     // # struct
     // assert struct1.another_struct.one == 1
     frame_dig -4
@@ -505,10 +581,10 @@ complex_sig:
     substring3
     dup
     extract 0 8
-    bytec_1 // 0x0000000000000001
+    bytec_2 // 0x0000000000000001
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:88-90
+    // a/contract.py:88-90
     // # struct
     // assert struct1.another_struct.one == 1
     // assert struct1.another_struct.two == "2"
@@ -520,12 +596,12 @@ complex_sig:
     dig 2
     cover 2
     substring3
-    // tests/artifacts/Arc4ABIMethod/contract.py:90
+    // a/contract.py:90
     // assert struct1.another_struct.two == "2"
-    bytec_2 // 0x000132
+    bytec_3 // 0x000132
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:91
+    // a/contract.py:91
     // assert struct1.another_struct_alias.one == 1
     frame_dig -4
     len
@@ -535,10 +611,10 @@ complex_sig:
     substring3
     dup
     extract 0 8
-    bytec_1 // 0x0000000000000001
+    bytec_2 // 0x0000000000000001
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:91-92
+    // a/contract.py:91-92
     // assert struct1.another_struct_alias.one == 1
     // assert struct1.another_struct_alias.two == "2"
     dup
@@ -547,28 +623,28 @@ complex_sig:
     dig 1
     len
     substring3
-    // tests/artifacts/Arc4ABIMethod/contract.py:90
+    // a/contract.py:90
     // assert struct1.another_struct.two == "2"
-    bytec_2 // 0x000132
-    // tests/artifacts/Arc4ABIMethod/contract.py:92
+    bytec_3 // 0x000132
+    // a/contract.py:92
     // assert struct1.another_struct_alias.two == "2"
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:93
+    // a/contract.py:93
     // assert struct1.three == 3
     frame_dig -4
     extract 4 16
     pushbytes 0x00000000000000000000000000000003
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:94
+    // a/contract.py:94
     // assert struct1.four == 4
     frame_dig -4
     extract 20 16
     pushbytes 0x00000000000000000000000000000004
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
+    // a/contract.py:96-97
     // # txn
     // assert txn.group_index == Txn.group_index - 1
     frame_dig -3
@@ -578,14 +654,14 @@ complex_sig:
     -
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
+    // a/contract.py:99-100
     // # acc
     // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
     txna ApplicationArgs 2
     pushbytes 0x01
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:101
+    // a/contract.py:101
     // assert acc.balance == acc.min_balance + 1234
     frame_dig -2
     acct_params_get AcctBalance
@@ -597,14 +673,108 @@ complex_sig:
     +
     ==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:102
+    // a/contract.py:102
     // assert five[0] == 5
     frame_dig -1
     extract 2 1
     pushbytes 0x05
     b==
     assert
-    // tests/artifacts/Arc4ABIMethod/contract.py:104
+    // a/contract.py:104
     // return struct1.another_struct.copy(), struct1.copy()
     frame_dig -4
     retsub
+
+
+// test_cases.a.contract.SignaturesContract.echo_resource_by_index(asset: uint64, app: uint64, acc: bytes) -> uint64, uint64, bytes:
+echo_resource_by_index:
+    // a/contract.py:106-111
+    // @arc4.abimethod(
+    //     resource_encoding="index",
+    // )
+    // def echo_resource_by_index(
+    //     self, asset: Asset, app: Application, acc: Account
+    // ) -> tuple[Asset, Application, Account]:
+    proto 3 3
+    // a/contract.py:112
+    // asset_idx = op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // a/contract.py:113
+    // assert asset == Txn.assets(asset_idx), "expected asset to be passed by index"
+    txnas Assets
+    frame_dig -3
+    ==
+    assert // expected asset to be passed by index
+    // a/contract.py:114
+    // app_idx = op.btoi(Txn.application_args(2))
+    txna ApplicationArgs 2
+    btoi
+    // a/contract.py:115
+    // assert app == Txn.applications(app_idx), "expected application to be passed by index"
+    txnas Applications
+    frame_dig -2
+    ==
+    assert // expected application to be passed by index
+    // a/contract.py:116
+    // acc_idx = op.btoi(Txn.application_args(3))
+    txna ApplicationArgs 3
+    btoi
+    // a/contract.py:117
+    // assert acc == Txn.accounts(acc_idx), "expected account to be passed by index"
+    txnas Accounts
+    frame_dig -1
+    ==
+    assert // expected account to be passed by index
+    // a/contract.py:118
+    // return asset, app, acc
+    frame_dig -3
+    frame_dig -2
+    frame_dig -1
+    retsub
+
+
+// test_cases.a.contract.SignaturesContract.echo_resource_by_value(asset: uint64, app: uint64, acc: bytes) -> uint64, uint64, bytes:
+echo_resource_by_value:
+    // a/contract.py:120-125
+    // @arc4.abimethod(
+    //     resource_encoding="value",
+    // )
+    // def echo_resource_by_value(
+    //     self, asset: Asset, app: Application, acc: Account
+    // ) -> tuple[Asset, Application, Account]:
+    proto 3 3
+    // a/contract.py:126
+    // asset_id = op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // a/contract.py:127
+    // assert asset.id == asset_id, "expected asset to be passed by value"
+    frame_dig -3
+    ==
+    assert // expected asset to be passed by value
+    // a/contract.py:128
+    // app_id = op.btoi(Txn.application_args(2))
+    txna ApplicationArgs 2
+    btoi
+    // a/contract.py:129
+    // assert app.id == app_id, "expected application to be passed by value"
+    frame_dig -2
+    ==
+    assert // expected application to be passed by value
+    // a/contract.py:131
+    // assert acc.bytes == address, "expected account to be passed by value"
+    frame_dig -1
+    // a/contract.py:130
+    // address = Txn.application_args(3)
+    txna ApplicationArgs 3
+    // a/contract.py:131
+    // assert acc.bytes == address, "expected account to be passed by value"
+    ==
+    assert // expected account to be passed by value
+    // a/contract.py:132
+    // return asset, app, acc
+    frame_dig -3
+    frame_dig -2
+    frame_dig -1
+    retsub
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
index a3b24344..fb205480 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
@@ -62,10 +62,20 @@
                     ]
                 }
             }
+        },
+        "echo_resource_by_index(asset,application,account)(uint64,uint64,address)": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)": {
+            "call_config": {
+                "no_op": "CALL"
+            }
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@14
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10

main_after_if_else@14:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_complex_sig_route@10:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
    // @arc4.abimethod
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
    // @arc4.abimethod
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // tests/artifacts/Arc4ABIMethod/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
    // @arc4.abimethod
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
    // @arc4.abimethod
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // tests/artifacts/Arc4ABIMethod/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-90
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91-92
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x151f7c75 0x0000000000000001 0x000132
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@16
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 0xd6c2ac7f 0x48142d5e // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))", method "echo_resource_by_index(asset,application,account)(uint64,uint64,address)", method "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10 main_echo_resource_by_index_route@11 main_echo_resource_by_value_route@12

main_after_if_else@16:
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_echo_resource_by_value_route@12:
    // a/contract.py:120-122
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    // a/contract.py:120-122
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    callsub echo_resource_by_value
    uncover 2
    itob
    uncover 2
    itob
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_echo_resource_by_index_route@11:
    // a/contract.py:106-108
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    btoi
    txnas Accounts
    // a/contract.py:106-108
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    callsub echo_resource_by_index
    uncover 2
    itob
    uncover 2
    itob
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_complex_sig_route@10:
    // a/contract.py:83
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // a/contract.py:83
    // @arc4.abimethod(resource_encoding="index")
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // a/contract.py:75
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // a/contract.py:75
    // @arc4.abimethod(resource_encoding="index")
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // a/contract.py:61
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // a/contract.py:61
    // @arc4.abimethod(resource_encoding="index")
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // a/contract.py:54
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // a/contract.py:54
    // @arc4.abimethod(resource_encoding="index")
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // a/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // a/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // a/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // a/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // a/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // a/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // a/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// test_cases.a.contract.SignaturesContract.create() -> void:
create:
    // a/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // a/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // a/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // a/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // a/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // a/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // a/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// test_cases.a.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // a/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // a/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// test_cases.a.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // a/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // a/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // a/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // a/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // a/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // a/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // a/contract.py:54-55
    // @arc4.abimethod(resource_encoding="index")
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // a/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // a/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // a/contract.py:61-64
    // @arc4.abimethod(resource_encoding="index")
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // a/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // a/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // a/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // a/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // a/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // a/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // a/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // a/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // a/contract.py:75-76
    // @arc4.abimethod(resource_encoding="index")
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // a/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // a/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // a/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // a/contract.py:83-86
    // @arc4.abimethod(resource_encoding="index")
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // a/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // a/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_2 // 0x0000000000000001
    b==
    assert
    // a/contract.py:88-90
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    // a/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_3 // 0x000132
    ==
    assert
    // a/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_2 // 0x0000000000000001
    b==
    assert
    // a/contract.py:91-92
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    // a/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_3 // 0x000132
    // a/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // a/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // a/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // a/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // a/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // a/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // a/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // a/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub


// test_cases.a.contract.SignaturesContract.echo_resource_by_index(asset: uint64, app: uint64, acc: bytes) -> uint64, uint64, bytes:
echo_resource_by_index:
    // a/contract.py:106-111
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    // def echo_resource_by_index(
    //     self, asset: Asset, app: Application, acc: Account
    // ) -> tuple[Asset, Application, Account]:
    proto 3 3
    // a/contract.py:112
    // asset_idx = op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // a/contract.py:113
    // assert asset == Txn.assets(asset_idx), "expected asset to be passed by index"
    txnas Assets
    frame_dig -3
    ==
    assert // expected asset to be passed by index
    // a/contract.py:114
    // app_idx = op.btoi(Txn.application_args(2))
    txna ApplicationArgs 2
    btoi
    // a/contract.py:115
    // assert app == Txn.applications(app_idx), "expected application to be passed by index"
    txnas Applications
    frame_dig -2
    ==
    assert // expected application to be passed by index
    // a/contract.py:116
    // acc_idx = op.btoi(Txn.application_args(3))
    txna ApplicationArgs 3
    btoi
    // a/contract.py:117
    // assert acc == Txn.accounts(acc_idx), "expected account to be passed by index"
    txnas Accounts
    frame_dig -1
    ==
    assert // expected account to be passed by index
    // a/contract.py:118
    // return asset, app, acc
    frame_dig -3
    frame_dig -2
    frame_dig -1
    retsub


// test_cases.a.contract.SignaturesContract.echo_resource_by_value(asset: uint64, app: uint64, acc: bytes) -> uint64, uint64, bytes:
echo_resource_by_value:
    // a/contract.py:120-125
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    // def echo_resource_by_value(
    //     self, asset: Asset, app: Application, acc: Account
    // ) -> tuple[Asset, Application, Account]:
    proto 3 3
    // a/contract.py:126
    // asset_id = op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // a/contract.py:127
    // assert asset.id == asset_id, "expected asset to be passed by value"
    frame_dig -3
    ==
    assert // expected asset to be passed by value
    // a/contract.py:128
    // app_id = op.btoi(Txn.application_args(2))
    txna ApplicationArgs 2
    btoi
    // a/contract.py:129
    // assert app.id == app_id, "expected application to be passed by value"
    frame_dig -2
    ==
    assert // expected application to be passed by value
    // a/contract.py:131
    // assert acc.bytes == address, "expected account to be passed by value"
    frame_dig -1
    // a/contract.py:130
    // address = Txn.application_args(3)
    txna ApplicationArgs 3
    // a/contract.py:131
    // assert acc.bytes == address, "expected account to be passed by value"
    ==
    assert // expected account to be passed by value
    // a/contract.py:132
    // return asset, app, acc
    frame_dig -3
    frame_dig -2
    frame_dig -1
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
@@ -245,6 +255,48 @@
                 "returns": {
                     "type": "((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
                 }
+            },
+            {
+                "name": "echo_resource_by_index",
+                "args": [
+                    {
+                        "type": "asset",
+                        "name": "asset"
+                    },
+                    {
+                        "type": "application",
+                        "name": "app"
+                    },
+                    {
+                        "type": "account",
+                        "name": "acc"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64,address)"
+                }
+            },
+            {
+                "name": "echo_resource_by_value",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "asset"
+                    },
+                    {
+                        "type": "uint64",
+                        "name": "app"
+                    },
+                    {
+                        "type": "address",
+                        "name": "acc"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64,address)"
+                }
             }
         ],
         "networks": {}
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json
index c4aca8f5..19f4f1d9 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc56.json
@@ -250,6 +250,64 @@
             "readonly": false,
             "events": [],
             "recommendations": {}
+        },
+        {
+            "name": "echo_resource_by_index",
+            "args": [
+                {
+                    "type": "asset",
+                    "name": "asset"
+                },
+                {
+                    "type": "application",
+                    "name": "app"
+                },
+                {
+                    "type": "account",
+                    "name": "acc"
+                }
+            ],
+            "returns": {
+                "type": "(uint64,uint64,address)"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
+        },
+        {
+            "name": "echo_resource_by_value",
+            "args": [
+                {
+                    "type": "uint64",
+                    "name": "asset"
+                },
+                {
+                    "type": "uint64",
+                    "name": "app"
+                },
+                {
+                    "type": "address",
+                    "name": "acc"
+                }
+            ],
+            "returns": {
+                "type": "(uint64,uint64,address)"
+            },
+            "actions": {
+                "create": [],
+                "call": [
+                    "NoOp"
+                ]
+            },
+            "readonly": false,
+            "events": [],
+            "recommendations": {}
         }
     ],
     "arcs": [
@@ -288,97 +346,137 @@
             "sourceInfo": [
                 {
                     "pc": [
-                        98,
-                        155,
-                        179,
-                        206,
-                        230,
-                        258,
-                        276,
-                        294
+                        117,
+                        153,
+                        196,
+                        248,
+                        272,
+                        299,
+                        323,
+                        351,
+                        369,
+                        387
                     ],
                     "errorMessage": "OnCompletion is not NoOp"
                 },
                 {
                     "pc": [
-                        503,
-                        508,
-                        676,
-                        681
+                        596,
+                        601,
+                        769,
+                        774
                     ],
                     "errorMessage": "account funded"
                 },
                 {
                     "pc": [
-                        444
+                        537
                     ],
                     "errorMessage": "application exists"
                 },
                 {
                     "pc": [
-                        407
+                        500
                     ],
                     "errorMessage": "asset exists"
                 },
                 {
                     "pc": [
-                        298
+                        391
                     ],
                     "errorMessage": "can only call when creating"
                 },
                 {
                     "pc": [
-                        101,
-                        158,
-                        182,
-                        209,
-                        233,
-                        261,
-                        279
+                        120,
+                        156,
+                        199,
+                        251,
+                        275,
+                        302,
+                        326,
+                        354,
+                        372
                     ],
                     "errorMessage": "can only call when not creating"
                 },
                 {
                     "pc": [
-                        439
+                        826
+                    ],
+                    "errorMessage": "expected account to be passed by index"
+                },
+                {
+                    "pc": [
+                        859
+                    ],
+                    "errorMessage": "expected account to be passed by value"
+                },
+                {
+                    "pc": [
+                        532
                     ],
                     "errorMessage": "expected app id to match provided app id"
                 },
                 {
                     "pc": [
-                        318
+                        816
+                    ],
+                    "errorMessage": "expected application to be passed by index"
+                },
+                {
+                    "pc": [
+                        852
+                    ],
+                    "errorMessage": "expected application to be passed by value"
+                },
+                {
+                    "pc": [
+                        806
+                    ],
+                    "errorMessage": "expected asset to be passed by index"
+                },
+                {
+                    "pc": [
+                        844
+                    ],
+                    "errorMessage": "expected asset to be passed by value"
+                },
+                {
+                    "pc": [
+                        411
                     ],
                     "errorMessage": "expected global to have app address"
                 },
                 {
                     "pc": [
-                        312
+                        405
                     ],
                     "errorMessage": "expected global to have app id"
                 },
                 {
                     "pc": [
-                        448
+                        541
                     ],
                     "errorMessage": "expected other app to have same creator"
                 },
                 {
                     "pc": [
-                        323,
-                        327
+                        416,
+                        420
                     ],
                     "errorMessage": "expected txn to have 0"
                 },
                 {
                     "pc": [
-                        309,
-                        454
+                        402,
+                        547
                     ],
                     "errorMessage": "transaction type is appl"
                 },
                 {
                     "pc": [
-                        246
+                        339
                     ],
                     "errorMessage": "transaction type is pay"
                 }
@@ -391,19 +489,19 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x0000000000000001 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@14
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10

main_after_if_else@14:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_complex_sig_route@10:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    pushbytes 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // tests/artifacts/Arc4ABIMethod/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // tests/artifacts/Arc4ABIMethod/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // tests/artifacts/Arc4ABIMethod/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // tests/artifacts/Arc4ABIMethod/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // tests/artifacts/Arc4ABIMethod/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // tests/artifacts/Arc4ABIMethod/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // tests/artifacts/Arc4ABIMethod/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // tests/artifacts/Arc4ABIMethod/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // tests/artifacts/Arc4ABIMethod/contract.py:54-55
    // @arc4.abimethod
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // tests/artifacts/Arc4ABIMethod/contract.py:61-64
    // @arc4.abimethod
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // tests/artifacts/Arc4ABIMethod/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // tests/artifacts/Arc4ABIMethod/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // tests/artifacts/Arc4ABIMethod/contract.py:75-76
    // @arc4.abimethod
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // tests/artifacts/Arc4ABIMethod/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // tests/artifacts/Arc4ABIMethod/contract.py:83-86
    // @arc4.abimethod
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // tests/artifacts/Arc4ABIMethod/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-90
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_1 // 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:91-92
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_2 // 0x000132
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0 4 6
    bytecblock 0x0000 0x151f7c75 0x0000000000000001 0x000132
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txn NumAppArgs
    bz main_after_if_else@16
    pushbytess 0x4c5c61ba 0xe18922d8 0x3b05cf17 0x0658dcc3 0x5b6447de 0x061f4e77 0xeaa89139 0x510e72a4 0xd6c2ac7f 0x48142d5e // method "create()void", method "sink(string,uint8[])void", method "alias(string,uint8[])void", method "with_txn(string,pay,uint8[])void", method "with_asset(string,asset,uint8[])void", method "with_app(string,application,uint64,uint8[])void", method "with_acc(string,account,uint8[])void", method "complex_sig(((uint64,string),(uint64,string),uint128,uint128),txn,account,uint8[])((uint64,string),((uint64,string),(uint64,string),uint128,uint128))", method "echo_resource_by_index(asset,application,account)(uint64,uint64,address)", method "echo_resource_by_value(uint64,uint64,address)(uint64,uint64,address)"
    txna ApplicationArgs 0
    match main_create_route@3 main_sink_route@4 main_alias_route@5 main_with_txn_route@6 main_with_asset_route@7 main_with_app_route@8 main_with_acc_route@9 main_complex_sig_route@10 main_echo_resource_by_index_route@11 main_echo_resource_by_value_route@12

main_after_if_else@16:
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    intc_1 // 0
    return

main_echo_resource_by_value_route@12:
    // a/contract.py:120-122
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    // a/contract.py:120-122
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    callsub echo_resource_by_value
    uncover 2
    itob
    uncover 2
    itob
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_echo_resource_by_index_route@11:
    // a/contract.py:106-108
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    btoi
    txnas Accounts
    // a/contract.py:106-108
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    callsub echo_resource_by_index
    uncover 2
    itob
    uncover 2
    itob
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_complex_sig_route@10:
    // a/contract.py:83
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // a/contract.py:83
    // @arc4.abimethod(resource_encoding="index")
    callsub complex_sig
    dig 1
    len
    intc_2 // 4
    +
    itob
    extract 6 2
    pushbytes 0x0004
    swap
    concat
    uncover 2
    concat
    swap
    concat
    bytec_1 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_with_acc_route@9:
    // a/contract.py:75
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // a/contract.py:75
    // @arc4.abimethod(resource_encoding="index")
    callsub with_acc
    intc_0 // 1
    return

main_with_app_route@8:
    // a/contract.py:61
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    txna ApplicationArgs 4
    // a/contract.py:61
    // @arc4.abimethod(resource_encoding="index")
    callsub with_app
    intc_0 // 1
    return

main_with_asset_route@7:
    // a/contract.py:54
    // @arc4.abimethod(resource_encoding="index")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    btoi
    txnas Assets
    txna ApplicationArgs 3
    // a/contract.py:54
    // @arc4.abimethod(resource_encoding="index")
    callsub with_asset
    intc_0 // 1
    return

main_with_txn_route@6:
    // a/contract.py:46
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    intc_0 // 1
    -
    dup
    gtxns TypeEnum
    intc_0 // pay
    ==
    assert // transaction type is pay
    txna ApplicationArgs 2
    // a/contract.py:46
    // @arc4.abimethod
    callsub with_txn
    intc_0 // 1
    return

main_alias_route@5:
    // a/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // a/contract.py:41
    // @arc4.abimethod(name="alias")
    callsub sink2
    intc_0 // 1
    return

main_sink_route@4:
    // a/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // a/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txna ApplicationArgs 2
    // a/contract.py:36
    // @arc4.abimethod
    callsub sink
    intc_0 // 1
    return

main_create_route@3:
    // a/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    !
    assert // can only call when creating
    callsub create
    intc_0 // 1
    return


// test_cases.a.contract.SignaturesContract.create() -> void:
create:
    // a/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    // a/contract.py:29
    // assert op.Global.current_application_id != 0, "expected global to have app id"
    global CurrentApplicationID
    assert // expected global to have app id
    // a/contract.py:31
    // op.Global.current_application_address != op.Global.zero_address
    global CurrentApplicationAddress
    global ZeroAddress
    !=
    // a/contract.py:30-32
    // assert (
    //     op.Global.current_application_address != op.Global.zero_address
    // ), "expected global to have app address"
    assert // expected global to have app address
    // a/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // a/contract.py:33
    // assert app_txn.app_id == 0, "expected txn to have 0"
    gtxns ApplicationID
    !
    assert // expected txn to have 0
    // a/contract.py:34
    // assert Txn.application_id == 0, "expected txn to have 0"
    txn ApplicationID
    !
    assert // expected txn to have 0
    retsub


// test_cases.a.contract.SignaturesContract.sink(value: bytes, arr: bytes) -> void:
sink:
    // a/contract.py:36-37
    // @arc4.abimethod
    // def sink(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // a/contract.py:38
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:39
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// test_cases.a.contract.SignaturesContract.sink2(value: bytes, arr: bytes) -> void:
sink2:
    // a/contract.py:41-42
    // @arc4.abimethod(name="alias")
    // def sink2(self, value: arc4.String, arr: UInt8Array) -> None:
    proto 2 0
    // a/contract.py:43
    // assert value
    frame_dig -2
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:44
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_txn(value: bytes, pay: uint64, arr: bytes) -> void:
with_txn:
    // a/contract.py:46-47
    // @arc4.abimethod
    // def with_txn(self, value: arc4.String, pay: gtxn.PaymentTransaction, arr: UInt8Array) -> None:
    proto 3 0
    // a/contract.py:48
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:49
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:50
    // assert pay.group_index == 0
    frame_dig -2
    gtxns GroupIndex
    !
    assert
    // a/contract.py:51
    // assert Txn.group_index == 1
    txn GroupIndex
    intc_0 // 1
    ==
    assert
    // a/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    pushint 123 // 123
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_asset(value: bytes, asset: uint64, arr: bytes) -> void:
with_asset:
    // a/contract.py:54-55
    // @arc4.abimethod(resource_encoding="index")
    // def with_asset(self, value: arc4.String, asset: Asset, arr: UInt8Array) -> None:
    proto 3 0
    // a/contract.py:56
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:57
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    pushint 123 // 123
    ==
    assert
    // a/contract.py:59
    // assert Txn.assets(0) == asset
    txna Assets 0
    frame_dig -2
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_app(value: bytes, app: uint64, app_id: bytes, arr: bytes) -> void:
with_app:
    // a/contract.py:61-64
    // @arc4.abimethod(resource_encoding="index")
    // def with_app(
    //     self, value: arc4.String, app: Application, app_id: arc4.UInt64, arr: UInt8Array
    // ) -> None:
    proto 4 0
    // a/contract.py:65
    // assert value
    frame_dig -4
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:66
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:67
    // assert app.id == app_id, "expected app id to match provided app id"
    frame_dig -3
    itob
    frame_dig -2
    b==
    assert // expected app id to match provided app id
    // a/contract.py:68
    // assert app.creator == op.Global.creator_address, "expected other app to have same creator"
    frame_dig -3
    app_params_get AppCreator
    assert // application exists
    global CreatorAddress
    ==
    assert // expected other app to have same creator
    // a/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    gtxns TypeEnum
    intc_3 // appl
    ==
    assert // transaction type is appl
    intc_1 // 0
    // a/contract.py:70
    // assert app_txn.apps(0) == op.Global.current_application_id
    dup
    gtxnsas Applications
    global CurrentApplicationID
    ==
    assert
    // a/contract.py:71
    // assert Txn.applications(0) == op.Global.current_application_id
    txna Applications 0
    global CurrentApplicationID
    ==
    assert
    // a/contract.py:69
    // app_txn = gtxn.ApplicationCallTransaction(0)
    intc_1 // 0
    // a/contract.py:72
    // assert app_txn.apps(1) == app
    intc_0 // 1
    gtxnsas Applications
    frame_dig -3
    ==
    assert
    // a/contract.py:73
    // assert Txn.applications(1) == app
    txna Applications 1
    frame_dig -3
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.with_acc(value: bytes, acc: bytes, arr: bytes) -> void:
with_acc:
    // a/contract.py:75-76
    // @arc4.abimethod(resource_encoding="index")
    // def with_acc(self, value: arc4.String, acc: Account, arr: UInt8Array) -> None:
    proto 3 0
    // a/contract.py:77
    // assert value
    frame_dig -3
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:78
    // assert arr
    frame_dig -1
    bytec_0 // 0x0000
    !=
    assert
    // a/contract.py:79
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // a/contract.py:80
    // assert Txn.accounts(0) == Txn.sender
    txna Accounts 0
    txn Sender
    ==
    assert
    // a/contract.py:81
    // assert Txn.accounts(1) == acc
    txna Accounts 1
    frame_dig -2
    ==
    assert
    retsub


// test_cases.a.contract.SignaturesContract.complex_sig(struct1: bytes, txn: uint64, acc: bytes, five: bytes) -> bytes, bytes:
complex_sig:
    // a/contract.py:83-86
    // @arc4.abimethod(resource_encoding="index")
    // def complex_sig(
    //     self, struct1: MyStruct, txn: algopy.gtxn.Transaction, acc: Account, five: UInt8Array
    // ) -> tuple[MyStructAlias, MyStruct]:
    proto 4 2
    // a/contract.py:87
    // assert Txn.num_app_args == 4
    txn NumAppArgs
    intc_2 // 4
    ==
    assert
    // a/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    intc_1 // 0
    extract_uint16
    frame_dig -4
    pushint 2 // 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8
    bytec_2 // 0x0000000000000001
    b==
    assert
    // a/contract.py:88-90
    // # struct
    // assert struct1.another_struct.one == 1
    // assert struct1.another_struct.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    dig 2
    cover 2
    substring3
    // a/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_3 // 0x000132
    ==
    assert
    // a/contract.py:91
    // assert struct1.another_struct_alias.one == 1
    frame_dig -4
    len
    frame_dig -4
    uncover 3
    uncover 2
    substring3
    dup
    extract 0 8
    bytec_2 // 0x0000000000000001
    b==
    assert
    // a/contract.py:91-92
    // assert struct1.another_struct_alias.one == 1
    // assert struct1.another_struct_alias.two == "2"
    dup
    pushint 8 // 8
    extract_uint16
    dig 1
    len
    substring3
    // a/contract.py:90
    // assert struct1.another_struct.two == "2"
    bytec_3 // 0x000132
    // a/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    ==
    assert
    // a/contract.py:93
    // assert struct1.three == 3
    frame_dig -4
    extract 4 16
    pushbytes 0x00000000000000000000000000000003
    b==
    assert
    // a/contract.py:94
    // assert struct1.four == 4
    frame_dig -4
    extract 20 16
    pushbytes 0x00000000000000000000000000000004
    b==
    assert
    // a/contract.py:96-97
    // # txn
    // assert txn.group_index == Txn.group_index - 1
    frame_dig -3
    gtxns GroupIndex
    txn GroupIndex
    intc_0 // 1
    -
    ==
    assert
    // a/contract.py:99-100
    // # acc
    // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
    txna ApplicationArgs 2
    pushbytes 0x01
    ==
    assert
    // a/contract.py:101
    // assert acc.balance == acc.min_balance + 1234
    frame_dig -2
    acct_params_get AcctBalance
    assert // account funded
    frame_dig -2
    acct_params_get AcctMinBalance
    assert // account funded
    pushint 1234 // 1234
    +
    ==
    assert
    // a/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 1
    pushbytes 0x05
    b==
    assert
    // a/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub


// test_cases.a.contract.SignaturesContract.echo_resource_by_index(asset: uint64, app: uint64, acc: bytes) -> uint64, uint64, bytes:
echo_resource_by_index:
    // a/contract.py:106-111
    // @arc4.abimethod(
    //     resource_encoding="index",
    // )
    // def echo_resource_by_index(
    //     self, asset: Asset, app: Application, acc: Account
    // ) -> tuple[Asset, Application, Account]:
    proto 3 3
    // a/contract.py:112
    // asset_idx = op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // a/contract.py:113
    // assert asset == Txn.assets(asset_idx), "expected asset to be passed by index"
    txnas Assets
    frame_dig -3
    ==
    assert // expected asset to be passed by index
    // a/contract.py:114
    // app_idx = op.btoi(Txn.application_args(2))
    txna ApplicationArgs 2
    btoi
    // a/contract.py:115
    // assert app == Txn.applications(app_idx), "expected application to be passed by index"
    txnas Applications
    frame_dig -2
    ==
    assert // expected application to be passed by index
    // a/contract.py:116
    // acc_idx = op.btoi(Txn.application_args(3))
    txna ApplicationArgs 3
    btoi
    // a/contract.py:117
    // assert acc == Txn.accounts(acc_idx), "expected account to be passed by index"
    txnas Accounts
    frame_dig -1
    ==
    assert // expected account to be passed by index
    // a/contract.py:118
    // return asset, app, acc
    frame_dig -3
    frame_dig -2
    frame_dig -1
    retsub


// test_cases.a.contract.SignaturesContract.echo_resource_by_value(asset: uint64, app: uint64, acc: bytes) -> uint64, uint64, bytes:
echo_resource_by_value:
    // a/contract.py:120-125
    // @arc4.abimethod(
    //     resource_encoding="value",
    // )
    // def echo_resource_by_value(
    //     self, asset: Asset, app: Application, acc: Account
    // ) -> tuple[Asset, Application, Account]:
    proto 3 3
    // a/contract.py:126
    // asset_id = op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // a/contract.py:127
    // assert asset.id == asset_id, "expected asset to be passed by value"
    frame_dig -3
    ==
    assert // expected asset to be passed by value
    // a/contract.py:128
    // app_id = op.btoi(Txn.application_args(2))
    txna ApplicationArgs 2
    btoi
    // a/contract.py:129
    // assert app.id == app_id, "expected application to be passed by value"
    frame_dig -2
    ==
    assert // expected application to be passed by value
    // a/contract.py:131
    // assert acc.bytes == address, "expected account to be passed by value"
    frame_dig -1
    // a/contract.py:130
    // address = Txn.application_args(3)
    txna ApplicationArgs 3
    // a/contract.py:131
    // assert acc.bytes == address, "expected account to be passed by value"
    ==
    assert // expected account to be passed by value
    // a/contract.py:132
    // return asset, app, acc
    frame_dig -3
    frame_dig -2
    frame_dig -1
    retsub
",
         "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "byteCode": {
-        "approval": "CiAEAQAEBiYDAgAACAAAAAAAAAABAwABMjEbQQA/gggETFxhugThiSLYBDsFzxcEBljcwwRbZEfeBAYfTncE6qiROQRRDnKkNhoAjggAxgC0AKIAhgBuAFMAOwACI0MxGRREMRhENhoBMRYiCTYaAhfAHDYaA4gBmUsBFSQIFlcGAoACAARMUE8CUExQgAQVH3x1TFCwIkMxGRREMRhENhoBNhoCF8AcNhoDiAE4IkMxGRREMRhENhoBNhoCF8AyNhoDNhoEiADbIkMxGRREMRhENhoBNhoCF8AwNhoDiAClIkMxGRREMRhENhoBMRYiCUk4ECISRDYaAogAaCJDMRkURDEYRDYaATYaAogASCJDMRkURDEYRDYaATYaAogAKCJDMRkURDEYFESIAAIiQyM4ECUSRDIIRDIKMgMTRCM4GBREMRgURImKAgCL/igTRIv/KBNEiYoCAIv+KBNEi/8oE0SJigMAi/0oE0SL/ygTRIv+OBYURDEWIhJEi/44CIF7EkSJigMAi/0oE0SL/ygTRIv+cQBEgXsSRDYwAIv+EkSJigQAi/woE0SL/ygTRIv9Fov+qESL/XIHRDIJEkQjOBAlEkQjScIyMggSRDYyADIIEkQjIsIyi/0SRDYyAYv9EkSJigMAi/0oE0SL/ygTRIv+cwBEi/5zAUSB0gkIEkQ2HAAxABJENhwBi/4SRImKBAIxGyQSRIv8I1mL/IECWYv8TwJLAlJJVwAIKahESYEIWUsBFUsCTgJSKhJEi/wVi/xPA08CUklXAAgpqERJgQhZSwEVUioSRIv8VwQQgBAAAAAAAAAAAAAAAAAAAAADqESL/FcUEIAQAAAAAAAAAAAAAAAAAAAABKhEi/04FjEWIgkSRDYaAoABARJEi/5zAESL/nMBRIHSCQgSRIv/VwIBgAEFqESL/Ik=",
+        "approval": "CiAEAQAEBiYEAgAABBUffHUIAAAAAAAAAAEDAAEyMRtBAE2CCgRMXGG6BOGJItgEOwXPFwQGWNzDBFtkR94EBh9OdwTqqJE5BFEOcqQE1sKsfwRIFC1eNhoAjgoBEAD+AOwA0AC4AJ0AhQBRACYAAiNDMRkURDEYRDYaARc2GgIXNhoDiAK7TwIWTwIWUExQKUxQsCJDMRkURDEYRDYaARfAMDYaAhfAMjYaAxfAHIgCaE8CFk8CFlBMUClMULAiQzEZFEQxGEQ2GgExFiIJNhoCF8AcNhoDiAGUSwEVJAgWVwYCgAIABExQTwJQTFApTFCwIkMxGRREMRhENhoBNhoCF8AcNhoDiAE4IkMxGRREMRhENhoBNhoCF8AyNhoDNhoEiADbIkMxGRREMRhENhoBNhoCF8AwNhoDiAClIkMxGRREMRhENhoBMRYiCUk4ECISRDYaAogAaCJDMRkURDEYRDYaATYaAogASCJDMRkURDEYRDYaATYaAogAKCJDMRkURDEYFESIAAIiQyM4ECUSRDIIRDIKMgMTRCM4GBREMRgURImKAgCL/igTRIv/KBNEiYoCAIv+KBNEi/8oE0SJigMAi/0oE0SL/ygTRIv+OBYURDEWIhJEi/44CIF7EkSJigMAi/0oE0SL/ygTRIv+cQBEgXsSRDYwAIv+EkSJigQAi/woE0SL/ygTRIv9Fov+qESL/XIHRDIJEkQjOBAlEkQjScIyMggSRDYyADIIEkQjIsIyi/0SRDYyAYv9EkSJigMAi/0oE0SL/ygTRIv+cwBEi/5zAUSB0gkIEkQ2HAAxABJENhwBi/4SRImKBAIxGyQSRIv8I1mL/IECWYv8TwJLAlJJVwAIKqhESYEIWUsBFUsCTgJSKxJEi/wVi/xPA08CUklXAAgqqERJgQhZSwEVUisSRIv8VwQQgBAAAAAAAAAAAAAAAAAAAAADqESL/FcUEIAQAAAAAAAAAAAAAAAAAAAABKhEi/04FjEWIgkSRDYaAoABARJEi/5zAESL/nMBRIHSCQgSRIv/VwIBgAEFqESL/ImKAwM2GgEXwDCL/RJENhoCF8Ayi/4SRDYaAxfAHIv/EkSL/Yv+i/+JigMDNhoBF4v9EkQ2GgIXi/4SRIv/NhoDEkSL/Yv+i/+J",
         "clear": "CoEBQw=="
     },
     "compilerInfo": {
         "compiler": "puya",
         "compilerVersion": {
-            "major": 4,
-            "minor": 10,
-            "patch": 0
+            "major": 99,
+            "minor": 99,
+            "patch": 99
         }
     },
     "events": [],
diff --git a/tests/artifacts/StateOps/contract.py b/tests/artifacts/StateOps/contract.py
index c2192b26..b0e14f06 100644
--- a/tests/artifacts/StateOps/contract.py
+++ b/tests/artifacts/StateOps/contract.py
@@ -22,7 +22,7 @@ def _get_1st_ref_index() -> UInt64:
 
 
 class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_balance(a)
         value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
@@ -35,7 +35,7 @@ def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
         ), "expected op.balance by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_min_balance(a)
         value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
@@ -48,7 +48,7 @@ def verify_acct_min_balance(self, a: algopy.Account) -> algopy.UInt64:
         ), "expected op.min_balance by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_auth_addr(self, a: algopy.Account) -> arc4.Address:
         value, funded = op.AcctParamsGet.acct_auth_addr(a)
         value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
@@ -56,7 +56,7 @@ def verify_acct_auth_addr(self, a: algopy.Account) -> arc4.Address:
         assert funded == funded_index, "expected funded by index to match"
         return arc4.Address(value)
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_num_uint(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
@@ -64,7 +64,7 @@ def verify_acct_total_num_uint(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_num_byte_slice(
@@ -74,7 +74,7 @@ def verify_acct_total_num_byte_slice(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_extra_app_pages(
@@ -84,7 +84,7 @@ def verify_acct_total_extra_app_pages(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_apps_created(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
@@ -92,7 +92,7 @@ def verify_acct_total_apps_created(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
@@ -100,7 +100,7 @@ def verify_acct_total_apps_opted_in(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_assets_created(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_assets_created(
@@ -110,7 +110,7 @@ def verify_acct_total_assets_created(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_assets(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
@@ -118,7 +118,7 @@ def verify_acct_total_assets(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_boxes(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
@@ -126,7 +126,7 @@ def verify_acct_total_boxes(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
         value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
@@ -134,7 +134,7 @@ def verify_acct_total_box_bytes(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_incentive_eligible(self, a: algopy.Account) -> bool:
         value, funded = op.AcctParamsGet.acct_incentive_eligible(a)
         value_index, funded_index = op.AcctParamsGet.acct_incentive_eligible(_get_1st_ref_index())
@@ -142,7 +142,7 @@ def verify_acct_incentive_eligible(self, a: algopy.Account) -> bool:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_last_heartbeat(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_last_heartbeat(a)
         value_index, funded_index = op.AcctParamsGet.acct_last_heartbeat(_get_1st_ref_index())
@@ -150,7 +150,7 @@ def verify_acct_last_heartbeat(self, a: algopy.Account) -> algopy.UInt64:
         assert funded == funded_index, "expected funded by index to match"
         return value
 
-    @arc4.abimethod()
+    @arc4.abimethod(resource_encoding="index")
     def verify_acct_last_proposed(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_last_proposed(a)
         value_index, funded_index = op.AcctParamsGet.acct_last_proposed(_get_1st_ref_index())

From 327bd394e08414eb0e71adb9a08263660372c74d Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Thu, 7 Aug 2025 16:14:13 +0700
Subject: [PATCH 4/8] chore: update dependencies to `rc.5`

---
 pyproject.toml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 13ee93da..6f4a7a70 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,7 @@ dependencies = [
     "pynacl>=1.4.0,<2",
     "ecdsa>=0.17.0",
     "coincurve>=19.0.1",
-    "algorand-python @ file://{root}/../puya/stubs",
+    "algorand-python; implementation_version=='v5.0.0-rc.5'",
 ]
 
 [project.urls]
@@ -50,7 +50,7 @@ type = "virtual"
 path = ".venv"
 python = "3.12"
 dependencies = [
-    "puyapy @ {root:parent:uri}/puya",
+    "puyapy; implementation_version=='v5.0.0-rc.5'",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -132,7 +132,7 @@ dependencies = [
     "pytest-cov>=4.1.0",
     "py-algorand-sdk>=2.4.0",
     "algokit-utils>=3.0.0",
-    "puyapy @ {root:parent:uri}/puya",
+    "puyapy; implementation_version=='v5.0.0-rc.5'",
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -183,7 +183,7 @@ post-install-commands = [
   "hatch run examples:reload_algopy_testing",
 ]
 dependencies = [
-    "algorand-python @ file://{root}/../puya/stubs",
+    "algorand-python; implementation_version=='v5.0.0-rc.5'",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",

From e65c1b0eff21305cdc248df0fc5f12327ab53cfc Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Fri, 8 Aug 2025 15:35:09 +0700
Subject: [PATCH 5/8] chore: trying to fix mypy issue

---
 src/_algopy_testing/itxn.py | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/_algopy_testing/itxn.py b/src/_algopy_testing/itxn.py
index f18f44e4..97b5838d 100644
--- a/src/_algopy_testing/itxn.py
+++ b/src/_algopy_testing/itxn.py
@@ -86,7 +86,13 @@ class InnerTransactionResult(_BaseInnerTransactionResult):
     pass
 
 
-class _BaseInnerTransactionFields:
+_TResult_co = typing.TypeVar(
+    "_TResult_co",
+    covariant=True,
+)
+
+
+class _BaseInnerTransactionFields(typing.Protocol[_TResult_co]):
     txn_class: type[_BaseInnerTransactionResult]
     fields: dict[str, typing.Any]
 
@@ -107,10 +113,10 @@ def set(self, **fields: typing.Any) -> None:
         _narrow_covariant_types(fields)
         self.fields.update(fields)
 
-    def submit(self) -> typing.Any:
+    def submit(self) -> _TResult_co:
         result = _get_itxn_result(self)
         lazy_context.active_group._add_itxn_group([result])  # type: ignore[list-item]
-        return result
+        return typing.cast("_TResult_co", result)
 
     def copy(self) -> typing.Self:
         return deepcopy(self)
@@ -124,36 +130,36 @@ def _check_fields(fields: dict[str, object]) -> None:
         raise ValueError(f"unexpected fields: {','.join(fields.keys())}")
 
 
-class InnerTransaction(_BaseInnerTransactionFields):
+class InnerTransaction(_BaseInnerTransactionFields[InnerTransactionResult]):
     txn_class = InnerTransactionResult
 
 
-class Payment(_BaseInnerTransactionFields):
+class Payment(_BaseInnerTransactionFields[PaymentInnerTransaction]):
     txn_class = PaymentInnerTransaction
 
 
-class KeyRegistration(_BaseInnerTransactionFields):
+class KeyRegistration(_BaseInnerTransactionFields[KeyRegistrationInnerTransaction]):
     txn_class = KeyRegistrationInnerTransaction
 
 
-class AssetConfig(_BaseInnerTransactionFields):
+class AssetConfig(_BaseInnerTransactionFields[AssetConfigInnerTransaction]):
     txn_class = AssetConfigInnerTransaction
 
 
-class AssetTransfer(_BaseInnerTransactionFields):
+class AssetTransfer(_BaseInnerTransactionFields[AssetTransferInnerTransaction]):
     txn_class = AssetTransferInnerTransaction
 
 
-class AssetFreeze(_BaseInnerTransactionFields):
+class AssetFreeze(_BaseInnerTransactionFields[AssetFreezeInnerTransaction]):
     txn_class = AssetFreezeInnerTransaction
 
 
-class ApplicationCall(_BaseInnerTransactionFields):
+class ApplicationCall(_BaseInnerTransactionFields[ApplicationCallInnerTransaction]):
     txn_class = ApplicationCallInnerTransaction
 
 
 def submit_txns(
-    *transactions: _BaseInnerTransactionFields,
+    *transactions: _BaseInnerTransactionFields[_TResult_co],
 ) -> tuple[_BaseInnerTransactionResult, ...]:
     if len(transactions) > algosdk.constants.TX_GROUP_LIMIT:
         raise ValueError("Cannot submit more than 16 inner transactions at once")
@@ -164,7 +170,9 @@ def submit_txns(
     return results
 
 
-def _get_itxn_result(itxn: _BaseInnerTransactionFields) -> _BaseInnerTransactionResult:
+def _get_itxn_result(
+    itxn: _BaseInnerTransactionFields[_TResult_co],
+) -> _BaseInnerTransactionResult:
     fields = itxn.fields
     txn_type = fields["type"]
     result = _TXN_HANDLERS[txn_type](fields)

From 8b6b60915c0413d7b653a5f498ee2ecc07b5a9f8 Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Fri, 8 Aug 2025 16:08:14 +0700
Subject: [PATCH 6/8] chore: define txn fields explicitly to get correct type
 hints

---
 src/_algopy_testing/models/txn_fields.py | 198 +++++++++++++++++++++--
 1 file changed, 181 insertions(+), 17 deletions(-)

diff --git a/src/_algopy_testing/models/txn_fields.py b/src/_algopy_testing/models/txn_fields.py
index f9f57987..d40de89b 100644
--- a/src/_algopy_testing/models/txn_fields.py
+++ b/src/_algopy_testing/models/txn_fields.py
@@ -193,7 +193,7 @@ class TransactionFieldsGetter(abc.ABC):
     def fields(self) -> dict[str, object]:
         raise NotImplementedError
 
-    # explicitly define some properties commonly accessed by algopy testing
+    # explicitly define all fields to have correct type hints
     @property
     def amount(self) -> algopy.UInt64:
         return self.fields["amount"]  # type: ignore[return-value]
@@ -202,10 +202,190 @@ def amount(self) -> algopy.UInt64:
     def app_id(self) -> algopy.Application:
         return self.fields["app_id"]  # type: ignore[return-value]
 
+    @property
+    def asset_amount(self) -> algopy.UInt64:
+        return self.fields["asset_amount"]  # type: ignore[return-value]
+
+    @property
+    def asset_close_to(self) -> algopy.Account:
+        return self.fields["asset_close_to"]  # type: ignore[return-value]
+
+    @property
+    def asset_name(self) -> algopy.Bytes:
+        return self.fields["asset_name"]  # type: ignore[return-value]
+
+    @property
+    def asset_receiver(self) -> algopy.Account:
+        return self.fields["asset_receiver"]  # type: ignore[return-value]
+
+    @property
+    def asset_sender(self) -> algopy.Account:
+        return self.fields["asset_sender"]  # type: ignore[return-value]
+
+    @property
+    def clawback(self) -> algopy.Account:
+        return self.fields["clawback"]  # type: ignore[return-value]
+
+    @property
+    def close_remainder_to(self) -> algopy.Account:
+        return self.fields["close_remainder_to"]  # type: ignore[return-value]
+
+    @property
+    def config_asset(self) -> algopy.Asset:
+        return self.fields["config_asset"]  # type: ignore[return-value]
+
+    @property
+    def created_app(self) -> algopy.Application:
+        return self.fields["created_app"]  # type: ignore[return-value]
+
+    @property
+    def created_asset(self) -> algopy.Asset:
+        return self.fields["created_asset"]  # type: ignore[return-value]
+
+    @property
+    def decimals(self) -> algopy.UInt64:
+        return self.fields["decimals"]  # type: ignore[return-value]
+
+    @property
+    def default_frozen(self) -> bool:
+        return self.fields["default_frozen"]  # type: ignore[return-value]
+
+    @property
+    def extra_program_pages(self) -> algopy.UInt64:
+        return self.fields["extra_program_pages"]  # type: ignore[return-value]
+
+    @property
+    def fee(self) -> algopy.UInt64:
+        return self.fields["fee"]  # type: ignore[return-value]
+
+    @property
+    def first_valid(self) -> algopy.UInt64:
+        return self.fields["first_valid"]  # type: ignore[return-value]
+
+    @property
+    def first_valid_time(self) -> algopy.UInt64:
+        return self.fields["first_valid_time"]  # type: ignore[return-value]
+
+    @property
+    def freeze(self) -> algopy.Account:
+        return self.fields["freeze"]  # type: ignore[return-value]
+
+    @property
+    def freeze_account(self) -> algopy.Account:
+        return self.fields["freeze_account"]  # type: ignore[return-value]
+
+    @property
+    def freeze_asset(self) -> algopy.Asset:
+        return self.fields["freeze_asset"]  # type: ignore[return-value]
+
+    @property
+    def frozen(self) -> bool:
+        return self.fields["frozen"]  # type: ignore[return-value]
+
+    @property
+    def global_num_bytes(self) -> algopy.UInt64:
+        return self.fields["global_num_bytes"]  # type: ignore[return-value]
+
+    @property
+    def global_num_uint(self) -> algopy.UInt64:
+        return self.fields["global_num_uint"]  # type: ignore[return-value]
+
+    @property
+    def last_valid(self) -> algopy.UInt64:
+        return self.fields["last_valid"]  # type: ignore[return-value]
+
+    @property
+    def lease(self) -> algopy.Bytes:
+        return self.fields["lease"]  # type: ignore[return-value]
+
+    @property
+    def local_num_bytes(self) -> algopy.UInt64:
+        return self.fields["local_num_bytes"]  # type: ignore[return-value]
+
+    @property
+    def local_num_uint(self) -> algopy.UInt64:
+        return self.fields["local_num_uint"]  # type: ignore[return-value]
+
+    @property
+    def manager(self) -> algopy.Account:
+        return self.fields["manager"]  # type: ignore[return-value]
+
+    @property
+    def metadata_hash(self) -> algopy.Bytes:
+        return self.fields["metadata_hash"]  # type: ignore[return-value]
+
+    @property
+    def non_participation(self) -> bool:
+        return self.fields["non_participation"]  # type: ignore[return-value]
+
+    @property
+    def note(self) -> algopy.Bytes:
+        return self.fields["note"]  # type: ignore[return-value]
+
+    @property
+    def on_completion(self) -> algopy.OnCompleteAction:
+        return self.fields["on_completion"]  # type: ignore[return-value]
+
+    @property
+    def receiver(self) -> algopy.Account:
+        return self.fields["receiver"]  # type: ignore[return-value]
+
+    @property
+    def rekey_to(self) -> algopy.Account:
+        return self.fields["rekey_to"]  # type: ignore[return-value]
+
+    @property
+    def reserve(self) -> algopy.Account:
+        return self.fields["reserve"]  # type: ignore[return-value]
+
+    @property
+    def selection_key(self) -> algopy.Bytes:
+        return self.fields["selection_key"]  # type: ignore[return-value]
+
     @property
     def sender(self) -> algopy.Account:
         return self.fields["sender"]  # type: ignore[return-value]
 
+    @property
+    def state_proof_key(self) -> algopy.Bytes:
+        return self.fields["state_proof_key"]  # type: ignore[return-value]
+
+    @property
+    def total(self) -> algopy.UInt64:
+        return self.fields["total"]  # type: ignore[return-value]
+
+    @property
+    def type(self) -> algopy.TransactionType:
+        return self.fields["type"]  # type: ignore[return-value]
+
+    @property
+    def unit_name(self) -> algopy.Bytes:
+        return self.fields["unit_name"]  # type: ignore[return-value]
+
+    @property
+    def url(self) -> algopy.Bytes:
+        return self.fields["url"]  # type: ignore[return-value]
+
+    @property
+    def vote_first(self) -> algopy.UInt64:
+        return self.fields["vote_first"]  # type: ignore[return-value]
+
+    @property
+    def vote_key(self) -> algopy.Bytes:
+        return self.fields["vote_key"]  # type: ignore[return-value]
+
+    @property
+    def vote_key_dilution(self) -> algopy.UInt64:
+        return self.fields["vote_key_dilution"]  # type: ignore[return-value]
+
+    @property
+    def vote_last(self) -> algopy.UInt64:
+        return self.fields["vote_last"]  # type: ignore[return-value]
+
+    @property
+    def xfer_asset(self) -> algopy.Asset:
+        return self.fields["xfer_asset"]  # type: ignore[return-value]
+
     @property
     def txn_id(self) -> algopy.Bytes:
         return self.fields["txn_id"]  # type: ignore[return-value]
@@ -262,10 +442,6 @@ def num_app_args(self) -> algopy.UInt64:
     def app_args(self) -> Callable[[algopy.UInt64 | int], algopy.Bytes]:
         return _create_array_accessor(self._app_args)
 
-    @property
-    def type(self) -> algopy.TransactionType:
-        return self.fields["type"]  # type: ignore[return-value]
-
     @property
     def type_bytes(self) -> algopy.Bytes:
         return Bytes(self.type.txn_name.encode("utf8"))
@@ -304,18 +480,6 @@ def clear_state_program_pages(self) -> Callable[[algopy.UInt64 | int], algopy.By
     def num_clear_state_program_pages(self) -> algopy.UInt64:
         return UInt64(len(self._clear_state_program_pages))
 
-    @property
-    def on_completion(self) -> algopy.OnCompleteAction:
-        return self.fields["on_completion"]  # type: ignore[return-value]
-
-    @property
-    def created_app(self) -> algopy.Application:
-        return self.fields["created_app"]  # type: ignore[return-value]
-
-    @property
-    def created_asset(self) -> algopy.Asset:
-        return self.fields["created_asset"]  # type: ignore[return-value]
-
     @property
     def _logs(self) -> Sequence[algopy.Bytes]:
         try:

From d9bdf74b27928fce97286c1e70d3402070bfcbe1 Mon Sep 17 00:00:00 2001
From: Bobby Lat <bobby.lat@makerx.com.au>
Date: Thu, 14 Aug 2025 09:59:05 +0700
Subject: [PATCH 7/8] chore: update puya dependency

---
 pyproject.toml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 6f4a7a70..c39ce388 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,7 @@ dependencies = [
     "pynacl>=1.4.0,<2",
     "ecdsa>=0.17.0",
     "coincurve>=19.0.1",
-    "algorand-python; implementation_version=='v5.0.0-rc.5'",
+    "algorand-python; implementation_version=='v5.0.0-rc.6'",
 ]
 
 [project.urls]
@@ -50,7 +50,7 @@ type = "virtual"
 path = ".venv"
 python = "3.12"
 dependencies = [
-    "puyapy; implementation_version=='v5.0.0-rc.5'",
+    "puyapy; implementation_version=='v5.0.0-rc.6'",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -132,7 +132,7 @@ dependencies = [
     "pytest-cov>=4.1.0",
     "py-algorand-sdk>=2.4.0",
     "algokit-utils>=3.0.0",
-    "puyapy; implementation_version=='v5.0.0-rc.5'",
+    "puyapy; implementation_version=='v5.0.0-rc.6'",
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -183,7 +183,7 @@ post-install-commands = [
   "hatch run examples:reload_algopy_testing",
 ]
 dependencies = [
-    "algorand-python; implementation_version=='v5.0.0-rc.5'",
+    "algorand-python; implementation_version=='v5.0.0-rc.6'",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",

From ff8a7fbad8afb4eeeac4b16cb4353393ca99cd07 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Wed, 3 Sep 2025 14:38:47 +0800
Subject: [PATCH 8/8] build: use git references for dependencies until puya 5.0
 is released

---
 pyproject.toml | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index c39ce388..6e628aed 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,9 @@ dependencies = [
     "pynacl>=1.4.0,<2",
     "ecdsa>=0.17.0",
     "coincurve>=19.0.1",
-    "algorand-python; implementation_version=='v5.0.0-rc.6'",
+    # TODO: uncomment below and remove direct git reference once puya 5.0 is released
+    # "algorand-python>=3",
+    "algorand-python@git+https://github.com/algorandfoundation/puya.git@v5.0.0-rc.6#subdirectory=stubs",
 ]
 
 [project.urls]
@@ -50,7 +52,9 @@ type = "virtual"
 path = ".venv"
 python = "3.12"
 dependencies = [
-    "puyapy; implementation_version=='v5.0.0-rc.6'",
+    # TODO: uncomment below and remove direct git reference once puya 5.0 is released
+    # "puyapy>=5",
+    "puyapy@git+https://github.com/algorandfoundation/puya.git@v5.0.0-rc.6",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",
@@ -132,7 +136,9 @@ dependencies = [
     "pytest-cov>=4.1.0",
     "py-algorand-sdk>=2.4.0",
     "algokit-utils>=3.0.0",
-    "puyapy; implementation_version=='v5.0.0-rc.6'",
+    # TODO: uncomment below and remove direct git reference once puya 5.0 is released
+    # "puyapy>=5",
+    "puyapy@git+https://github.com/algorandfoundation/puya.git@v5.0.0-rc.6",
 ]
 
 [tool.hatch.envs.test.scripts]
@@ -183,7 +189,9 @@ post-install-commands = [
   "hatch run examples:reload_algopy_testing",
 ]
 dependencies = [
-    "algorand-python; implementation_version=='v5.0.0-rc.6'",
+    # TODO: uncomment below and remove direct git reference once puya 5.0 is released
+    # "algorand-python>=3",
+    "algorand-python@git+https://github.com/algorandfoundation/puya.git@v5.0.0-rc.6#subdirectory=stubs",
     "pytest>=7.4",
     "pytest-mock>=3.10.0",
     "pytest-xdist[psutil]>=3.3",