From 98b23a13f5d5cc751e5c11ad0b89a1acd052666c Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 10:43:38 +0800
Subject: [PATCH 01/23] chore: update coverage script

---
 scripts/check_stubs_cov.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/scripts/check_stubs_cov.py b/scripts/check_stubs_cov.py
index 0ebf923..3af439d 100644
--- a/scripts/check_stubs_cov.py
+++ b/scripts/check_stubs_cov.py
@@ -127,9 +127,6 @@ def collect_stubs(stubs_dir: Path, relative_module: str) -> dict[str, ASTNodeDef
 def collect_coverage(stubs: dict[str, ASTNodeDefinition]) -> list[CoverageResult]:
     result = []
     for full_name, stub in stubs.items():
-        if "GTxn" in full_name:
-            print("stop")
-
         coverage = _get_impl_coverage(full_name, stub)
         if coverage:
             try:
@@ -287,6 +284,8 @@ def _compare_stub_impl(stub: ast.AST, impl: object, impl_path: Path) -> ImplCove
             "ne",
         )
     }
+    # excluding special fields used in typing hints
+    default_impls.update(("__match_args__", "__match_value__"))
     missing = sorted(stub_members.difference({*impl_members, *default_impls}))
     return ImplCoverage(impl_path, sorted(stub_members), missing)
 

From ea1cd660765d954222ca19fe549cd5cf0d1ea293 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 10:57:41 +0800
Subject: [PATCH 02/23] chore: ensure unimplemented stubs appear at top of
 check stubs report

---
 scripts/check_stubs_cov.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/scripts/check_stubs_cov.py b/scripts/check_stubs_cov.py
index 3af439d..1c2da7a 100644
--- a/scripts/check_stubs_cov.py
+++ b/scripts/check_stubs_cov.py
@@ -142,7 +142,7 @@ def collect_coverage(stubs: dict[str, ASTNodeDefinition]) -> list[CoverageResult
             CoverageResult(
                 full_name=full_name,
                 stub_file=str(stub.path.relative_to(STUBS_ROOT)),
-                impl_file=impl_file,
+                impl_file=impl_file or "MISSING!",
                 coverage=coverage.coverage if coverage else 0,
                 missing=", ".join(coverage.missing if coverage else []),
             )
@@ -153,18 +153,16 @@ def collect_coverage(stubs: dict[str, ASTNodeDefinition]) -> list[CoverageResult
 def print_results(results: list[CoverageResult]) -> None:
     table = PrettyTable(
         field_names=["Name", "Implementation", "Source Stub", "Coverage", "Missing"],
-        sortby="Coverage",
         header=True,
         border=True,
         padding_width=2,
-        reversesort=True,
         left_padding_width=0,
         right_padding_width=1,
         align="l",
         max_width=100,
     )
 
-    for result in results:
+    for result in sorted(results, key=lambda c: c.coverage):
         table.add_row(
             [
                 result.full_name,
@@ -206,7 +204,6 @@ def _get_impl_coverage(symbol: str, stub: ASTNodeDefinition) -> ImplCoverage | N
     try:
         impl = getattr(mod, name)
     except AttributeError:
-        print(f"Attribute {name} not found in module {module}")
         return None
 
     try:

From 83e1422f7700d1d3e5999d12b0aee0be5f581aef Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 16:09:34 +0800
Subject: [PATCH 03/23] chore: improve coverage of some excluded
 implementations

---
 scripts/check_stubs_cov.py | 97 +++++++++++++++++++++++++++++---------
 1 file changed, 76 insertions(+), 21 deletions(-)

diff --git a/scripts/check_stubs_cov.py b/scripts/check_stubs_cov.py
index 1c2da7a..9582436 100644
--- a/scripts/check_stubs_cov.py
+++ b/scripts/check_stubs_cov.py
@@ -1,7 +1,9 @@
 import ast
+import importlib
 import inspect
 import site
 import sys
+import typing
 from collections.abc import Iterable
 from pathlib import Path
 from typing import NamedTuple
@@ -13,6 +15,35 @@
 STUBS_ROOT = SITE_PACKAGES / "algopy-stubs"
 IMPL = PROJECT_ROOT / "src"
 ROOT_MODULE = "algopy"
+_ADDITIONAL_GLOBAL_IMPLS = [
+    "_algopy_testing.op.global_values._Global",
+    "_algopy_testing.op.global_values.GlobalFields",
+]
+_ADDITIONAL_TXN_IMPLS = [
+    "_algopy_testing.models.txn_fields.TransactionFields",
+    "_algopy_testing.models.txn_fields.TransactionFieldsGetter",
+    "_algopy_testing.op.constants.OP_MEMBER_TO_TXN_MEMBER",
+]
+_ADDITIONAL_TYPE_IMPLS = {
+    "algopy.Asset": ["_algopy_testing.models.asset.AssetFields"],
+    "algopy.Account": ["_algopy_testing.models.account.AccountFields"],
+    "algopy.Application": ["_algopy_testing.models.application.ApplicationFields"],
+    "algopy.Global": _ADDITIONAL_GLOBAL_IMPLS,
+    "algopy.Txn": _ADDITIONAL_TXN_IMPLS,
+    "algopy.op.Global": _ADDITIONAL_GLOBAL_IMPLS,
+    "algopy.op.GTxn": _ADDITIONAL_TXN_IMPLS,
+    "algopy.op.GITxn": _ADDITIONAL_TXN_IMPLS,
+    "algopy.op.Txn": _ADDITIONAL_TXN_IMPLS,
+    "algopy.op.ITxn": _ADDITIONAL_TXN_IMPLS,
+    "algopy.op.ITxnCreate": _ADDITIONAL_TXN_IMPLS,
+    "algopy.op.AcctParamsGet": ["_algopy_testing.op.misc._AcctParamsGet"],
+    "algopy.op.AppParamsGet": ["_algopy_testing.op.misc._AppParamsGet"],
+    "algopy.op.AssetParamsGet": ["_algopy_testing.op.misc._AssetParamsGet"],
+    "algopy.op.AssetHoldingGet": ["_algopy_testing.op.misc._AssetHoldingGet"],
+    "algopy.op.AppGlobal": ["_algopy_testing.op.misc._AppGlobal"],
+    "algopy.op.AppLocal": ["_algopy_testing.op.misc._AppLocal"],
+    "algopy.op.Scratch": ["_algopy_testing.op.misc._Scratch"],
+}
 
 
 class ASTNodeDefinition(NamedTuple):
@@ -213,20 +244,6 @@ def _get_impl_coverage(symbol: str, stub: ASTNodeDefinition) -> ImplCoverage | N
         if hasattr(impl, "__class__"):
             try:
                 impl_path = Path(inspect.getfile(impl.__class__))
-                # For special cases like GTxn and GITxn, assume full implementation
-                if name in [
-                    "GTxn",
-                    "GITxn",
-                    "Txn",
-                    "ITxn",
-                    "Global",
-                    "AssetConfigInnerTransaction",
-                    "Contract",
-                    "ApplicationCallInnerTransaction",
-                    "UFixedNxM",
-                    "BigUFixedNxM",
-                ]:
-                    return ImplCoverage(impl_path)
             except TypeError:
                 print(f"Warning: Could not determine file for {symbol}")
                 return None
@@ -234,18 +251,56 @@ def _get_impl_coverage(symbol: str, stub: ASTNodeDefinition) -> ImplCoverage | N
             print(f"Warning: Could not determine file for {symbol}")
             return None
 
-    return _compare_stub_impl(stub.node, impl, impl_path)
+    return _compare_stub_impl(stub.node, symbol, impl, impl_path)
 
 
-def _compare_stub_impl(stub: ast.AST, impl: object, impl_path: Path) -> ImplCoverage:
+def _get_impl_members(impl_name: str, impl: object) -> set[str]:
+    if isinstance(impl, type):
+        impl_mros: list[object] = [
+            typ for typ in impl.mro() if typ.__module__.startswith("_algopy_testing")
+        ]
+    else:
+        impl_mros = []
+    for additional_type in _ADDITIONAL_TYPE_IMPLS.get(impl_name, []):
+        impl_mros.append(_resolve_fullname(additional_type))
+
+    impl_members = set[str]()
+    for impl_typ in impl_mros:
+        if typing.is_typeddict(impl_typ) and isinstance(impl_typ, type):
+            for typed_dict_mro in impl_typ.mro():
+                ann = getattr(typed_dict_mro, "__annotations__", None)
+                if isinstance(ann, dict):
+                    impl_members.update(ann.keys())
+        elif isinstance(impl_typ, dict):
+            impl_members.update(impl_typ.keys())
+        elif isinstance(impl_typ, type):
+            members = list(vars(impl_typ).keys())
+            impl_members.update(members)
+        else:
+            raise ValueError(f"unexpected implementation type, {impl_typ}")
+    # special case for ITxnCreate
+    if impl_name == "algopy.op.ITxnCreate":
+        impl_members = {f"set_{member}" for member in impl_members}
+        impl_members.update(("begin", "next", "submit"))
+    return impl_members
+
+
+def _resolve_fullname(fullname: str) -> object:
+    # note this assumes no nested classes
+    module_name, type_name = fullname.rsplit(".", maxsplit=1)
+    module = importlib.import_module(module_name)
+    return getattr(module, type_name)
+
+
+def _compare_stub_impl(
+    stub: ast.AST, impl_name: str, impl: object, impl_path: Path
+) -> ImplCoverage:
     # classes are really the only types that can be "partially implemented"
     # from a typing perspective
-    if not isinstance(stub, ast.ClassDef):
+    # algopy.uenumerate is typed as a class, but is really just a function
+    if not isinstance(stub, ast.ClassDef) or impl_name == "algopy.uenumerate":
         return ImplCoverage(impl_path)
-
-    # using vars to only get explicitly implemented members
-    # need more sophisticated approach if implementations start using inheritance
-    impl_members = set(vars(impl))
+    impl_members = _get_impl_members(impl_name, impl)
     stub_members = set()
     for stmt in stub.body:
         if isinstance(stmt, ast.FunctionDef):

From 6a3c8540adb2f7f1c9cebe83c96eee8443c0bdfc Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 10:43:57 +0800
Subject: [PATCH 04/23] fix: added missing __contains__ implementation for
 `algopy.Bytes`

---
 src/_algopy_testing/primitives/bytes.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/_algopy_testing/primitives/bytes.py b/src/_algopy_testing/primitives/bytes.py
index f21f815..5da10db 100644
--- a/src/_algopy_testing/primitives/bytes.py
+++ b/src/_algopy_testing/primitives/bytes.py
@@ -27,6 +27,10 @@ def __init__(self, value: bytes = b"") -> None:
         check_type(value, bytes)
         self.value = as_bytes(value)
 
+    def __contains__(self, item: Bytes | bytes) -> bool:
+        item_bytes = as_bytes(item)
+        return item_bytes in self.value
+
     def __repr__(self) -> str:
         return repr(self.value)
 

From d43ecca5a5af38bc62546206b60595222592d2a3 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 15:19:29 +0800
Subject: [PATCH 05/23] fix: update `algopy.CompiledContract` and
 `algopy.CompiledLogicSig` to be NamedTuples

---
 src/_algopy_testing/compiled.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/_algopy_testing/compiled.py b/src/_algopy_testing/compiled.py
index 3be3061..ca802fb 100644
--- a/src/_algopy_testing/compiled.py
+++ b/src/_algopy_testing/compiled.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 # ruff: noqa: ARG001, PLR0913
-import dataclasses
 import typing
 
 from _algopy_testing.utils import raise_mocked_function_error
@@ -12,8 +11,7 @@
     import algopy
 
 
-@dataclasses.dataclass
-class CompiledContract:
+class CompiledContract(typing.NamedTuple):
     approval_program: tuple[algopy.Bytes, algopy.Bytes]
     clear_state_program: tuple[algopy.Bytes, algopy.Bytes]
     extra_program_pages: algopy.UInt64
@@ -23,8 +21,7 @@ class CompiledContract:
     local_bytes: algopy.UInt64
 
 
-@dataclasses.dataclass
-class CompiledLogicSig:
+class CompiledLogicSig(typing.NamedTuple):
     account: algopy.Account
 
 

From 64b21efcb4c6bbc2b341a4694ce0f6f4650274cb Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 15:20:00 +0800
Subject: [PATCH 06/23] fix: include `ARC4Contract` in `algopy.arc4` namespace

---
 src/_algopy_testing/arc4.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/_algopy_testing/arc4.py b/src/_algopy_testing/arc4.py
index d013f6b..572a5a4 100644
--- a/src/_algopy_testing/arc4.py
+++ b/src/_algopy_testing/arc4.py
@@ -17,6 +17,7 @@
     UINT512_SIZE,
 )
 from _algopy_testing.models.account import Account
+from _algopy_testing.models.contract import ARC4Contract
 from _algopy_testing.mutable import (
     MutableBytes,
     add_mutable_callback,
@@ -42,6 +43,7 @@
 
 __all__ = [
     "ARC4Client",
+    "ARC4Contract",
     "Address",
     "BigUFixedNxM",
     "BigUIntN",

From 113e531065455cd4a4da479095f8c5052a934405 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 15:20:42 +0800
Subject: [PATCH 07/23] fix: add missing mappings for `algopy.op.Txn` members

---
 src/_algopy_testing/models/txn_fields.py |  1 +
 src/_algopy_testing/op/constants.py      | 23 +++++++++++++++++++
 tests/test_op.py                         | 28 ++++++++++++++++++++++++
 3 files changed, 52 insertions(+)

diff --git a/src/_algopy_testing/models/txn_fields.py b/src/_algopy_testing/models/txn_fields.py
index 779b622..f9f5798 100644
--- a/src/_algopy_testing/models/txn_fields.py
+++ b/src/_algopy_testing/models/txn_fields.py
@@ -123,6 +123,7 @@ class TransactionFields(  # type: ignore[misc]
     "app_id": Application,
     "xfer_asset": Asset,
     "freeze_asset": Asset,
+    "freeze_account": Account,
     "config_asset": Asset,
     "frozen": bool,
     "default_frozen": bool,
diff --git a/src/_algopy_testing/op/constants.py b/src/_algopy_testing/op/constants.py
index c2a856f..93abce3 100644
--- a/src/_algopy_testing/op/constants.py
+++ b/src/_algopy_testing/op/constants.py
@@ -4,4 +4,27 @@
     "application_args": "app_args",
     "applications": "apps",
     "application_id": "app_id",
+    "config_asset_clawback": "clawback",
+    "config_asset_decimals": "decimals",
+    "config_asset_default_frozen": "default_frozen",
+    "config_asset_freeze": "freeze",
+    "config_asset_manager": "manager",
+    "config_asset_metadata_hash": "metadata_hash",
+    "config_asset_name": "asset_name",
+    "config_asset_reserve": "reserve",
+    "config_asset_total": "total",
+    "config_asset_unit_name": "unit_name",
+    "config_asset_url": "url",
+    "created_application_id": "created_app",
+    "created_asset_id": "created_asset",
+    "freeze_asset_account": "freeze_account",
+    "freeze_asset_frozen": "frozen",
+    "global_num_byte_slice": "global_num_bytes",
+    "local_num_byte_slice": "local_num_bytes",
+    "nonparticipation": "non_participation",
+    "num_applications": "num_apps",
+    "tx_id": "txn_id",
+    "selection_pk": "selection_key",
+    "state_proof_pk": "state_proof_key",
+    "vote_pk": "vote_key",
 }
diff --git a/tests/test_op.py b/tests/test_op.py
index e287f33..050e47b 100644
--- a/tests/test_op.py
+++ b/tests/test_op.py
@@ -1033,3 +1033,31 @@ def test_globals(context: AlgopyTestContext) -> None:
 
     assert first_group_id != second_group_id, "expected unique group ids"
     assert first_timestamp <= second_timestamp, "expected unique group ids"
+
+
+def test_txn_op_mappings(context: AlgopyTestContext) -> None:
+    txn1 = context.any.txn.transaction()
+    with context.txn.create_group(gtxns=[txn1]):
+        assert algopy.Txn.config_asset_clawback == algopy.Account()
+        assert algopy.Txn.config_asset_decimals == algopy.UInt64()
+        assert not algopy.Txn.config_asset_default_frozen
+        assert algopy.Txn.config_asset_freeze == algopy.Account()
+        assert algopy.Txn.config_asset_manager == algopy.Account()
+        assert algopy.Txn.config_asset_metadata_hash == algopy.Bytes()
+        assert algopy.Txn.config_asset_name == algopy.Bytes()
+        assert algopy.Txn.config_asset_reserve == algopy.Account()
+        assert algopy.Txn.config_asset_total == algopy.UInt64()
+        assert algopy.Txn.config_asset_unit_name == algopy.Bytes()
+        assert algopy.Txn.config_asset_url == algopy.Bytes()
+        assert algopy.Txn.created_application_id == algopy.Application()
+        assert algopy.Txn.created_asset_id == algopy.Asset()
+        assert algopy.Txn.freeze_asset_account == algopy.Account()
+        assert not algopy.Txn.freeze_asset_frozen
+        assert algopy.Txn.global_num_byte_slice == algopy.UInt64()
+        assert algopy.Txn.local_num_byte_slice == algopy.UInt64()
+        assert not algopy.Txn.nonparticipation
+        assert algopy.Txn.num_applications == algopy.UInt64()
+        assert isinstance(algopy.Txn.tx_id, algopy.Bytes)
+        assert algopy.Txn.selection_pk == algopy.Bytes()
+        assert algopy.Txn.state_proof_pk == algopy.Bytes()
+        assert algopy.Txn.vote_pk == algopy.Bytes()

From ce01316efe25b5b1e03b03f7924f711e47702e75 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 16:09:46 +0800
Subject: [PATCH 08/23] refactor: simplify EllipticCurve mock

---
 src/_algopy_testing/op/crypto.py | 19 +++++++++++++------
 tests/test_op.py                 |  5 +++++
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/_algopy_testing/op/crypto.py b/src/_algopy_testing/op/crypto.py
index 27d1465..fc3dbb6 100644
--- a/src/_algopy_testing/op/crypto.py
+++ b/src/_algopy_testing/op/crypto.py
@@ -186,12 +186,19 @@ class EC(enum.StrEnum):
     BLS12_381g2 = "BLS12_381g2"
 
 
-class _EllipticCurve:
-    def __getattr__(self, name: str) -> typing.Any:
-        def mock(*_args: typing.Any, **_kwargs: typing.Any) -> None:
-            raise_mocked_function_error(f"{EllipticCurve}.{name}")
+class _MockedMember:
 
-        return mock
+    def __set_name__(self, owner: type, name: str) -> None:
+        self.name = f"{owner.__name__}.{name}"
 
+    def __call__(self, *_args: typing.Any, **_kwargs: typing.Any) -> None:
+        raise_mocked_function_error(self.name)
 
-EllipticCurve = _EllipticCurve()
+
+class EllipticCurve:
+    add = _MockedMember()
+    map_to = _MockedMember()
+    pairing_check = _MockedMember()
+    scalar_mul = _MockedMember()
+    scalar_mul_multi = _MockedMember()
+    subgroup_check = _MockedMember()
diff --git a/tests/test_op.py b/tests/test_op.py
index 050e47b..ce32df8 100644
--- a/tests/test_op.py
+++ b/tests/test_op.py
@@ -1061,3 +1061,8 @@ def test_txn_op_mappings(context: AlgopyTestContext) -> None:
         assert algopy.Txn.selection_pk == algopy.Bytes()
         assert algopy.Txn.state_proof_pk == algopy.Bytes()
         assert algopy.Txn.vote_pk == algopy.Bytes()
+
+
+def test_elliptic_curve_mocked() -> None:
+    with pytest.raises(NotImplementedError, match="EllipticCurve.add"):
+        op.EllipticCurve.add()

From 5ed97be4d5c8877bb9075ae548a2b07a19425b47 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 16:54:57 +0800
Subject: [PATCH 09/23] chore: further coverage check improvements

---
 scripts/check_stubs_cov.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/scripts/check_stubs_cov.py b/scripts/check_stubs_cov.py
index 9582436..d130cec 100644
--- a/scripts/check_stubs_cov.py
+++ b/scripts/check_stubs_cov.py
@@ -24,6 +24,8 @@
     "_algopy_testing.models.txn_fields.TransactionFieldsGetter",
     "_algopy_testing.op.constants.OP_MEMBER_TO_TXN_MEMBER",
 ]
+
+# mapping of stub types to additional implementation types to scan for members
 _ADDITIONAL_TYPE_IMPLS = {
     "algopy.Asset": ["_algopy_testing.models.asset.AssetFields"],
     "algopy.Account": ["_algopy_testing.models.account.AccountFields"],
@@ -36,15 +38,18 @@
     "algopy.op.Txn": _ADDITIONAL_TXN_IMPLS,
     "algopy.op.ITxn": _ADDITIONAL_TXN_IMPLS,
     "algopy.op.ITxnCreate": _ADDITIONAL_TXN_IMPLS,
-    "algopy.op.AcctParamsGet": ["_algopy_testing.op.misc._AcctParamsGet"],
     "algopy.op.AppParamsGet": ["_algopy_testing.op.misc._AppParamsGet"],
-    "algopy.op.AssetParamsGet": ["_algopy_testing.op.misc._AssetParamsGet"],
     "algopy.op.AssetHoldingGet": ["_algopy_testing.op.misc._AssetHoldingGet"],
     "algopy.op.AppGlobal": ["_algopy_testing.op.misc._AppGlobal"],
     "algopy.op.AppLocal": ["_algopy_testing.op.misc._AppLocal"],
     "algopy.op.Scratch": ["_algopy_testing.op.misc._Scratch"],
 }
 
+# mapping of stub types to members that may be present but not found when discovering members
+_ADDITIONAL_MEMBERS = {
+    "algopy.Asset": ["id"],
+}
+
 
 class ASTNodeDefinition(NamedTuple):
     node: ast.AST
@@ -264,7 +269,7 @@ def _get_impl_members(impl_name: str, impl: object) -> set[str]:
     for additional_type in _ADDITIONAL_TYPE_IMPLS.get(impl_name, []):
         impl_mros.append(_resolve_fullname(additional_type))
 
-    impl_members = set[str]()
+    impl_members = set[str](_ADDITIONAL_MEMBERS.get(impl_name, []))
     for impl_typ in impl_mros:
         if typing.is_typeddict(impl_typ) and isinstance(impl_typ, type):
             for typed_dict_mro in impl_typ.mro():

From d28b6ee88af8a106cc8348cb1775d4780a3836c4 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 16:55:30 +0800
Subject: [PATCH 10/23] refactor: add explicit methods to AcctParamsGet and
 AssetParamsGet

---
 src/_algopy_testing/op/misc.py | 219 ++++++++++++++++++++++++++-------
 1 file changed, 175 insertions(+), 44 deletions(-)

diff --git a/src/_algopy_testing/op/misc.py b/src/_algopy_testing/op/misc.py
index d903893..ed6cb73 100644
--- a/src/_algopy_testing/op/misc.py
+++ b/src/_algopy_testing/op/misc.py
@@ -110,50 +110,181 @@ def app_opted_in(
     return account.is_opted_in(app)
 
 
-class _AcctParamsGet:
-    def __getattr__(
-        self, name: str
-    ) -> typing.Callable[
-        [algopy.Account | algopy.UInt64 | int], tuple[algopy.UInt64 | algopy.Account, bool]
-    ]:
-        def get_account_param(
-            a: algopy.Account | algopy.UInt64 | int,
-        ) -> tuple[algopy.UInt64 | algopy.Account, bool]:
-            account = _get_account(a)
-            field = name.removeprefix("acct_")
-            if field == "auth_addr":
-                field = "auth_address"
-
-            return getattr(account, field), account.balance != 0
-
-        return get_account_param
-
-
-AcctParamsGet = _AcctParamsGet()
-
-
-class _AssetParamsGet:
-    def __getattr__(
-        self, name: str
-    ) -> typing.Callable[[algopy.Asset | algopy.UInt64 | int], tuple[typing.Any, bool]]:
-        def get_asset_param(a: algopy.Asset | algopy.UInt64 | int) -> tuple[typing.Any, bool]:
-            try:
-                asset = _get_asset(a)
-            except ValueError:
-                return UInt64(0), False
-
-            short_name = name.removeprefix("asset_")
-            try:
-                return getattr(asset, short_name), True
-            except AttributeError:
-                raise AttributeError(
-                    f"'{self.__class__.__name__}' object has no attribute '{name}'"
-                ) from None
-
-        return get_asset_param
-
-
-AssetParamsGet = _AssetParamsGet()
+class AcctParamsGet:
+    @staticmethod
+    def acct_auth_addr(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
+        account = _get_account(a)
+        return account.auth_address, account.balance != 0
+
+    @staticmethod
+    def acct_balance(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.balance, account.balance != 0
+
+    @staticmethod
+    def acct_min_balance(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.min_balance, account.balance != 0
+
+    @staticmethod
+    def acct_auth_address(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.auth_address, account.balance != 0
+
+    @staticmethod
+    def acct_total_num_uint(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_num_uint, account.balance != 0
+
+    @staticmethod
+    def acct_total_num_byte_slice(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_num_byte_slice, account.balance != 0
+
+    @staticmethod
+    def acct_total_extra_app_pages(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_extra_app_pages, account.balance != 0
+
+    @staticmethod
+    def acct_total_apps_created(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_apps_created, account.balance != 0
+
+    @staticmethod
+    def acct_total_apps_opted_in(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_apps_opted_in, account.balance != 0
+
+    @staticmethod
+    def acct_total_assets_created(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_assets_created, account.balance != 0
+
+    @staticmethod
+    def acct_total_assets(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_assets, account.balance != 0
+
+    @staticmethod
+    def acct_total_boxes(a: algopy.Account | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_boxes, account.balance != 0
+
+    @staticmethod
+    def acct_total_box_bytes(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.total_box_bytes, account.balance != 0
+
+
+class AssetParamsGet:
+    @staticmethod
+    def asset_clawback(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.clawback, True
+
+    @staticmethod
+    def asset_creator(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.creator, True
+
+    @staticmethod
+    def asset_freeze(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.freeze, True
+
+    @staticmethod
+    def asset_manager(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.manager, True
+
+    @staticmethod
+    def asset_reserve(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Account, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.reserve, True
+
+    @staticmethod
+    def asset_total(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False
+        return asset.total, True
+
+    @staticmethod
+    def asset_decimals(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.UInt64, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False
+        return asset.decimals, True
+
+    @staticmethod
+    def asset_default_frozen(a: algopy.Asset | algopy.UInt64 | int) -> tuple[bool, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.default_frozen, True
+
+    @staticmethod
+    def asset_unit_name(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Bytes, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.unit_name, True
+
+    @staticmethod
+    def asset_name(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Bytes, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.name, True
+
+    @staticmethod
+    def asset_url(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Bytes, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.url, True
+
+    @staticmethod
+    def asset_metadata_hash(a: algopy.Asset | algopy.UInt64 | int) -> tuple[algopy.Bytes, bool]:
+        try:
+            asset = _get_asset(a)
+        except ValueError:
+            return UInt64(0), False  # type: ignore[return-value]
+        return asset.metadata_hash, True
 
 
 class _AssetHoldingGet:

From 30e53a5e7ac3114d916d305cc97c8da93034fde3 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 17:06:24 +0800
Subject: [PATCH 11/23] feat: add `algopy.arc4.Struct._replace` introduced in
 algorand-python 2.5.0

---
 src/_algopy_testing/arc4.py |  6 ++++++
 tests/arc4/test_struct.py   | 10 ++++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/_algopy_testing/arc4.py b/src/_algopy_testing/arc4.py
index 572a5a4..eb4c593 100644
--- a/src/_algopy_testing/arc4.py
+++ b/src/_algopy_testing/arc4.py
@@ -1096,6 +1096,12 @@ def _as_tuple(self) -> Tuple:  # type: ignore[type-arg]
         tuple_items = tuple(getattr(self, field.name) for field in dataclasses.fields(self))
         return Tuple(tuple_items)
 
+    def _replace(self, **kwargs: typing.Any) -> typing.Self:
+        copy = self.copy()
+        for field, value in kwargs.items():
+            setattr(copy, field, value)
+        return copy
+
 
 class ARC4Client:
     pass
diff --git a/tests/arc4/test_struct.py b/tests/arc4/test_struct.py
index a77c4a8..24f399b 100644
--- a/tests/arc4/test_struct.py
+++ b/tests/arc4/test_struct.py
@@ -349,6 +349,16 @@ def test_struct_kw_only() -> None:
         StructWithKwOnly(arc4.UInt64(1), arc4.UInt64(2), arc4.Bool(True), arc4.String("hello"))  # type: ignore[misc]
 
 
+def test_replace() -> None:
+    x = StructWithKwOnly(
+        a=arc4.UInt64(1), b=arc4.UInt64(2), c=arc4.Bool(True), d=arc4.String("hello")
+    )
+    y = x._replace(a=arc4.UInt64(2))
+    assert x.a == arc4.UInt64(1)
+    assert y.a == arc4.UInt64(2)
+    assert x != y
+
+
 def _compare_abi_and_arc4_values(
     arc4_value: typing.Any,
     abi_value: typing.Any,

From b22fde49f42216e8e3e32932086e903c7189b2c1 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 17:12:55 +0800
Subject: [PATCH 12/23] feat: update `algopy.op.Global` with fields added in
 AVM 11

---
 src/_algopy_testing/op/global_values.py | 5 +++++
 src/_algopy_testing/utils.py            | 5 +++++
 tests/test_op.py                        | 1 +
 3 files changed, 11 insertions(+)

diff --git a/src/_algopy_testing/op/global_values.py b/src/_algopy_testing/op/global_values.py
index 587179d..6caa161 100644
--- a/src/_algopy_testing/op/global_values.py
+++ b/src/_algopy_testing/op/global_values.py
@@ -31,6 +31,11 @@ class GlobalFields(TypedDict, total=False):
     asset_opt_in_min_balance: algopy.UInt64
     genesis_hash: algopy.Bytes
     opcode_budget: Callable[[], int]
+    payouts_enabled: bool
+    payouts_go_online_fee: algopy.UInt64
+    payouts_max_balance: algopy.UInt64
+    payouts_min_balance: algopy.UInt64
+    payouts_percent: algopy.UInt64
 
 
 class _Global:
diff --git a/src/_algopy_testing/utils.py b/src/_algopy_testing/utils.py
index 5239e39..bbe3ab9 100644
--- a/src/_algopy_testing/utils.py
+++ b/src/_algopy_testing/utils.py
@@ -171,6 +171,11 @@ def get_default_global_fields() -> GlobalFields:
         "asset_create_min_balance": algopy.UInt64(DEFAULT_ASSET_CREATE_MIN_BALANCE),
         "asset_opt_in_min_balance": algopy.UInt64(DEFAULT_ASSET_OPT_IN_MIN_BALANCE),
         "genesis_hash": algopy.Bytes(DEFAULT_GLOBAL_GENESIS_HASH),
+        "payouts_enabled": False,
+        "payouts_go_online_fee": algopy.UInt64(),
+        "payouts_max_balance": algopy.UInt64(),
+        "payouts_min_balance": algopy.UInt64(),
+        "payouts_percent": algopy.UInt64(),
     }
 
 
diff --git a/tests/test_op.py b/tests/test_op.py
index ce32df8..7be8bba 100644
--- a/tests/test_op.py
+++ b/tests/test_op.py
@@ -1017,6 +1017,7 @@ def test_globals(context: AlgopyTestContext) -> None:
         assert algopy.Global.creator_address == creator
         assert algopy.Global.current_application_id == app
         assert algopy.Global.current_application_address == app.address
+        assert not algopy.Global.payouts_enabled
 
     txn2 = context.any.txn.payment()
     txn3 = context.any.txn.application_call()

From 5d9a9935a34fe34a62d52385972a0d0e7a913f26 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 17:26:48 +0800
Subject: [PATCH 13/23] feat: add `avm_version` to `algopy.Contract` class
 options

---
 src/_algopy_testing/models/contract.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/_algopy_testing/models/contract.py b/src/_algopy_testing/models/contract.py
index 328f164..61744a8 100644
--- a/src/_algopy_testing/models/contract.py
+++ b/src/_algopy_testing/models/contract.py
@@ -36,6 +36,7 @@ class _ContractMeta(type):
     _name: str
     _scratch_slots: typing.Any
     _state_totals: StateTotals | None
+    _avm_version: int
 
     def __init__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
         super().__init__(*args, **kwargs)
@@ -93,10 +94,12 @@ def __init_subclass__(
             algopy.urange | tuple[int | algopy.urange, ...] | list[int | algopy.urange] | None
         ) = None,
         state_totals: StateTotals | None = None,
+        avm_version: int = 10,
     ):
         cls._name = name or cls.__name__
         cls._scratch_slots = scratch_slots
         cls._state_totals = state_totals
+        cls._avm_version = avm_version
 
     def approval_program(self) -> algopy.UInt64 | bool:
         raise NotImplementedError("`approval_program` is not implemented.")

From 089e9a18023d01963d200006529d8039c963e45c Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 17:27:57 +0800
Subject: [PATCH 14/23] feat: update `algopy.op.AcctParamsGet` with fields
 added in AVM 11

---
 src/_algopy_testing/models/account.py |  6 ++++++
 src/_algopy_testing/op/misc.py        | 21 +++++++++++++++++++++
 tests/artifacts/StateOps/contract.py  | 26 +++++++++++++++++++++++++-
 tests/test_op.py                      |  3 +++
 4 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/src/_algopy_testing/models/account.py b/src/_algopy_testing/models/account.py
index 4982c70..58c6da2 100644
--- a/src/_algopy_testing/models/account.py
+++ b/src/_algopy_testing/models/account.py
@@ -30,6 +30,9 @@ class AccountFields(typing.TypedDict, total=False):
     total_assets: algopy.UInt64
     total_boxes: algopy.UInt64
     total_box_bytes: algopy.UInt64
+    incentive_eligible: bool
+    last_heartbeat: algopy.UInt64
+    last_proposed: algopy.UInt64
 
 
 def get_empty_account() -> AccountContextData:
@@ -47,6 +50,9 @@ def get_empty_account() -> AccountContextData:
             "total_assets": UInt64(),
             "total_boxes": UInt64(),
             "total_box_bytes": UInt64(),
+            "incentive_eligible": False,
+            "last_heartbeat": UInt64(),
+            "last_proposed": UInt64(),
         },
     )
 
diff --git a/src/_algopy_testing/op/misc.py b/src/_algopy_testing/op/misc.py
index ed6cb73..15178b6 100644
--- a/src/_algopy_testing/op/misc.py
+++ b/src/_algopy_testing/op/misc.py
@@ -188,6 +188,27 @@ def acct_total_box_bytes(
         account = _get_account(a)
         return account.total_box_bytes, account.balance != 0
 
+    @staticmethod
+    def acct_incentive_eligible(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[bool, bool]:
+        account = _get_account(a)
+        return account.incentive_eligible, account.balance != 0
+
+    @staticmethod
+    def acct_last_heartbeat(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.last_heartbeat, account.balance != 0
+
+    @staticmethod
+    def acct_last_proposed(
+        a: algopy.Account | algopy.UInt64 | int,
+    ) -> tuple[algopy.UInt64, bool]:
+        account = _get_account(a)
+        return account.last_proposed, account.balance != 0
+
 
 class AssetParamsGet:
     @staticmethod
diff --git a/tests/artifacts/StateOps/contract.py b/tests/artifacts/StateOps/contract.py
index d39574f..9a9f946 100644
--- a/tests/artifacts/StateOps/contract.py
+++ b/tests/artifacts/StateOps/contract.py
@@ -21,7 +21,7 @@ def _get_1st_ref_index() -> UInt64:
     return op.btoi(Txn.application_args(1))
 
 
-class StateAcctParamsGetContract(ARC4Contract):
+class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     @arc4.abimethod()
     def verify_acct_balance(self, a: algopy.Account) -> algopy.UInt64:
         value, funded = op.AcctParamsGet.acct_balance(a)
@@ -134,6 +134,30 @@ 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()
+    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())
+        assert value == value_index, "expected value by index to match"
+        assert funded == funded_index, "expected funded by index to match"
+        return value
+
+    @arc4.abimethod()
+    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())
+        assert value == value_index, "expected value by index to match"
+        assert funded == funded_index, "expected funded by index to match"
+        return value
+
+    @arc4.abimethod()
+    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())
+        assert value == value_index, "expected value by index to match"
+        assert funded == funded_index, "expected funded by index to match"
+        return value
+
 
 class StateAssetHoldingContract(ARC4Contract):
     @arc4.abimethod()
diff --git a/tests/test_op.py b/tests/test_op.py
index 7be8bba..f4309c0 100644
--- a/tests/test_op.py
+++ b/tests/test_op.py
@@ -563,6 +563,9 @@ def test_app_params_get(
         ("verify_acct_total_assets", 0),
         ("verify_acct_total_boxes", 0),
         ("verify_acct_total_box_bytes", 0),
+        ("verify_acct_incentive_eligible", False),
+        ("verify_acct_last_heartbeat", 0),
+        ("verify_acct_last_proposed", 0),
     ],
 )
 def test_acct_params_get(

From 767cdf08a141e58042b5d00651489af5c53c0c3f Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 17:28:12 +0800
Subject: [PATCH 15/23] chore: refresh test artifacts

---
 .../data/SignaturesContract.approval.teal     |  324 ++--
 .../data/SignaturesContract.arc32.json        |    4 +-
 .../data/SignaturesContract.clear.teal        |    8 +-
 .../data/Arc4InnerTxnsContract.approval.teal  |   39 +-
 .../data/Arc4InnerTxnsContract.arc32.json     |    4 +-
 .../data/Arc4InnerTxnsContract.clear.teal     |    8 +-
 .../Arc4PrimitiveOpsContract.approval.teal    | 1552 ++++++++---------
 .../data/Arc4PrimitiveOpsContract.arc32.json  |    4 +-
 .../data/Arc4PrimitiveOpsContract.clear.teal  |    8 +-
 .../data/BoxContract.approval.teal            |  109 +-
 .../BoxContract/data/BoxContract.arc32.json   |    4 +-
 .../BoxContract/data/BoxContract.clear.teal   |    8 +-
 .../Contains/data/MyContract.approval.teal    | 1367 +--------------
 .../Contains/data/MyContract.clear.teal       |    6 +-
 .../data/AppExpectingEffects.approval.teal    |  105 +-
 .../data/AppExpectingEffects.arc32.json       |    4 +-
 .../data/AppExpectingEffects.clear.teal       |    8 +-
 .../data/CryptoOpsContract.approval.teal      |  633 ++++---
 .../data/CryptoOpsContract.arc32.json         |    4 +-
 .../data/CryptoOpsContract.clear.teal         |    8 +-
 .../data/GlobalStateValidator.approval.teal   |   44 +-
 .../data/GlobalStateValidator.arc32.json      |    4 +-
 .../data/GlobalStateValidator.clear.teal      |    8 +-
 .../MiscellaneousOpsContract.approval.teal    |  885 +++++-----
 .../data/MiscellaneousOpsContract.arc32.json  |    4 +-
 .../data/MiscellaneousOpsContract.clear.teal  |    8 +-
 .../data/PrimitiveOpsContract.approval.teal   | 1551 ++++++++--------
 .../data/PrimitiveOpsContract.arc32.json      |    4 +-
 .../data/PrimitiveOpsContract.clear.teal      |    8 +-
 .../data/GlobalStateContract.approval.teal    | 1140 +++++-------
 .../data/GlobalStateContract.arc32.json       |    4 +-
 .../data/GlobalStateContract.clear.teal       |    8 +-
 .../data/ITxnOpsContract.approval.teal        |  102 +-
 .../StateOps/data/ITxnOpsContract.arc32.json  |    4 +-
 .../StateOps/data/ITxnOpsContract.clear.teal  |    8 +-
 .../data/LocalStateContract.approval.teal     |  642 +++----
 .../data/LocalStateContract.arc32.json        |    4 +-
 .../data/LocalStateContract.clear.teal        |    8 +-
 .../StateAcctParamsGetContract.approval.teal  |  591 ++++---
 .../StateAcctParamsGetContract.arc32.json     |   58 +-
 .../StateAcctParamsGetContract.clear.teal     |   10 +-
 .../data/StateAppGlobalContract.approval.teal |  269 +--
 .../data/StateAppGlobalContract.arc32.json    |    4 +-
 .../data/StateAppGlobalContract.clear.teal    |    8 +-
 .../StateAppGlobalExContract.approval.teal    |   96 +-
 .../data/StateAppGlobalExContract.arc32.json  |    4 +-
 .../data/StateAppGlobalExContract.clear.teal  |    8 +-
 .../data/StateAppLocalContract.approval.teal  |  337 ++--
 .../data/StateAppLocalContract.arc32.json     |    4 +-
 .../data/StateAppLocalContract.clear.teal     |    8 +-
 .../StateAppLocalExContract.approval.teal     |   74 +-
 .../data/StateAppLocalExContract.arc32.json   |    4 +-
 .../data/StateAppLocalExContract.clear.teal   |    8 +-
 .../data/StateAppParamsContract.approval.teal |  444 +++--
 .../data/StateAppParamsContract.arc32.json    |    4 +-
 .../data/StateAppParamsContract.clear.teal    |    8 +-
 .../StateAssetHoldingContract.approval.teal   |   91 +-
 .../data/StateAssetHoldingContract.arc32.json |    4 +-
 .../data/StateAssetHoldingContract.clear.teal |    8 +-
 .../StateAssetParamsContract.approval.teal    |  580 +++---
 .../data/StateAssetParamsContract.arc32.json  |    4 +-
 .../data/StateAssetParamsContract.clear.teal  |    8 +-
 62 files changed, 4798 insertions(+), 6479 deletions(-)

diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
index 9975148..a6b7daf 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.approval.teal
@@ -1,103 +1,116 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.approval_program:
+// 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):
-    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))"
+    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@1 main_sink_route@2 main_alias_route@3 main_with_txn_route@4 main_with_asset_route@5 main_with_app_route@6 main_with_acc_route@7 main_complex_sig_route@8
-    err // reject transaction
+    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_create_route@1:
-    // tests/artifacts/Arc4ABIMethod/contract.py:26
-    // @arc4.abimethod(create="require")
-    txn OnCompletion
-    !
-    assert // OnCompletion is NoOp
-    txn ApplicationID
-    !
-    assert // is creating
-    callsub create
-    int 1
+main_after_if_else@14:
+    // tests/artifacts/Arc4ABIMethod/contract.py:25
+    // class SignaturesContract(ARC4Contract):
+    intc_1 // 0
     return
 
-main_sink_route@2:
-    // tests/artifacts/Arc4ABIMethod/contract.py:36
+main_complex_sig_route@10:
+    // tests/artifacts/Arc4ABIMethod/contract.py:83
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    // tests/artifacts/Arc4ABIMethod/contract.py:36
+    btoi
+    txnas Accounts
+    txna ApplicationArgs 3
+    // tests/artifacts/Arc4ABIMethod/contract.py:83
     // @arc4.abimethod
-    callsub sink
-    int 1
+    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_alias_route@3:
-    // tests/artifacts/Arc4ABIMethod/contract.py:41
-    // @arc4.abimethod(name="alias")
+main_with_acc_route@9:
+    // tests/artifacts/Arc4ABIMethod/contract.py:75
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    int 1
+    btoi
+    txnas Accounts
+    txna ApplicationArgs 3
+    // tests/artifacts/Arc4ABIMethod/contract.py:75
+    // @arc4.abimethod
+    callsub with_acc
+    intc_0 // 1
     return
 
-main_with_txn_route@4:
-    // tests/artifacts/Arc4ABIMethod/contract.py:46
+main_with_app_route@8:
+    // tests/artifacts/Arc4ABIMethod/contract.py:61
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/Arc4ABIMethod/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
-    txn GroupIndex
-    int 1
-    -
-    dup
-    gtxns TypeEnum
-    int pay
-    ==
-    assert // transaction type is pay
     txna ApplicationArgs 2
-    // tests/artifacts/Arc4ABIMethod/contract.py:46
+    btoi
+    txnas Applications
+    txna ApplicationArgs 3
+    txna ApplicationArgs 4
+    // tests/artifacts/Arc4ABIMethod/contract.py:61
     // @arc4.abimethod
-    callsub with_txn
-    int 1
+    callsub with_app
+    intc_0 // 1
     return
 
-main_with_asset_route@5:
+main_with_asset_route@7:
     // tests/artifacts/Arc4ABIMethod/contract.py:54
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/Arc4ABIMethod/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -108,106 +121,92 @@ main_with_asset_route@5:
     // tests/artifacts/Arc4ABIMethod/contract.py:54
     // @arc4.abimethod
     callsub with_asset
-    int 1
+    intc_0 // 1
     return
 
-main_with_app_route@6:
-    // tests/artifacts/Arc4ABIMethod/contract.py:61
+main_with_txn_route@6:
+    // tests/artifacts/Arc4ABIMethod/contract.py:46
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    btoi
-    txnas Applications
-    txna ApplicationArgs 3
-    txna ApplicationArgs 4
-    // tests/artifacts/Arc4ABIMethod/contract.py:61
+    // tests/artifacts/Arc4ABIMethod/contract.py:46
     // @arc4.abimethod
-    callsub with_app
-    int 1
+    callsub with_txn
+    intc_0 // 1
     return
 
-main_with_acc_route@7:
-    // tests/artifacts/Arc4ABIMethod/contract.py:75
-    // @arc4.abimethod
+main_alias_route@5:
+    // tests/artifacts/Arc4ABIMethod/contract.py:41
+    // @arc4.abimethod(name="alias")
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    int 1
+    // tests/artifacts/Arc4ABIMethod/contract.py:41
+    // @arc4.abimethod(name="alias")
+    callsub sink2
+    intc_0 // 1
     return
 
-main_complex_sig_route@8:
-    // tests/artifacts/Arc4ABIMethod/contract.py:83
+main_sink_route@4:
+    // tests/artifacts/Arc4ABIMethod/contract.py:36
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/Arc4ABIMethod/contract.py:25
     // class SignaturesContract(ARC4Contract):
     txna ApplicationArgs 1
-    txn GroupIndex
-    int 1
-    -
     txna ApplicationArgs 2
-    btoi
-    txnas Accounts
-    txna ApplicationArgs 3
-    // tests/artifacts/Arc4ABIMethod/contract.py:83
+    // tests/artifacts/Arc4ABIMethod/contract.py:36
     // @arc4.abimethod
-    callsub complex_sig
-    swap
-    dup
-    len
-    int 4
-    +
-    itob
-    extract 6 2
-    byte 0x0004
-    swap
-    concat
-    swap
-    concat
-    swap
-    concat
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    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:26-27
-    // @arc4.abimethod(create="require")
-    // def create(self) -> None:
-    proto 0 0
     // tests/artifacts/Arc4ABIMethod/contract.py:28
     // app_txn = gtxn.ApplicationCallTransaction(0)
-    int 0
+    intc_1 // 0
     gtxns TypeEnum
-    int appl
+    intc_3 // appl
     ==
     assert // transaction type is appl
     // tests/artifacts/Arc4ABIMethod/contract.py:29
@@ -226,7 +225,7 @@ create:
     assert // expected global to have app address
     // tests/artifacts/Arc4ABIMethod/contract.py:28
     // app_txn = gtxn.ApplicationCallTransaction(0)
-    int 0
+    intc_1 // 0
     // tests/artifacts/Arc4ABIMethod/contract.py:33
     // assert app_txn.app_id == 0, "expected txn to have 0"
     gtxns ApplicationID
@@ -249,13 +248,13 @@ sink:
     // tests/artifacts/Arc4ABIMethod/contract.py:38
     // assert value
     frame_dig -2
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:39
     // assert arr
     frame_dig -1
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     retsub
@@ -270,13 +269,13 @@ sink2:
     // tests/artifacts/Arc4ABIMethod/contract.py:43
     // assert value
     frame_dig -2
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:44
     // assert arr
     frame_dig -1
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     retsub
@@ -291,13 +290,13 @@ with_txn:
     // tests/artifacts/Arc4ABIMethod/contract.py:48
     // assert value
     frame_dig -3
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:49
     // assert arr
     frame_dig -1
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:50
@@ -309,14 +308,14 @@ with_txn:
     // tests/artifacts/Arc4ABIMethod/contract.py:51
     // assert Txn.group_index == 1
     txn GroupIndex
-    int 1
+    intc_0 // 1
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:52
     // assert pay.amount == 123
     frame_dig -2
     gtxns Amount
-    int 123
+    pushint 123 // 123
     ==
     assert
     retsub
@@ -331,13 +330,13 @@ with_asset:
     // tests/artifacts/Arc4ABIMethod/contract.py:56
     // assert value
     frame_dig -3
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:57
     // assert arr
     frame_dig -1
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:58
@@ -345,7 +344,7 @@ with_asset:
     frame_dig -2
     asset_params_get AssetTotal
     assert // asset exists
-    int 123
+    pushint 123 // 123
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:59
@@ -368,13 +367,13 @@ with_app:
     // tests/artifacts/Arc4ABIMethod/contract.py:65
     // assert value
     frame_dig -4
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:66
     // assert arr
     frame_dig -1
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:67
@@ -394,12 +393,12 @@ with_app:
     assert // expected other app to have same creator
     // tests/artifacts/Arc4ABIMethod/contract.py:69
     // app_txn = gtxn.ApplicationCallTransaction(0)
-    int 0
+    intc_1 // 0
     gtxns TypeEnum
-    int appl
+    intc_3 // appl
     ==
     assert // transaction type is appl
-    int 0
+    intc_1 // 0
     // tests/artifacts/Arc4ABIMethod/contract.py:70
     // assert app_txn.apps(0) == op.Global.current_application_id
     dup
@@ -415,10 +414,10 @@ with_app:
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:69
     // app_txn = gtxn.ApplicationCallTransaction(0)
-    int 0
+    intc_1 // 0
     // tests/artifacts/Arc4ABIMethod/contract.py:72
     // assert app_txn.apps(1) == app
-    int 1
+    intc_0 // 1
     gtxnsas Applications
     frame_dig -3
     ==
@@ -441,13 +440,13 @@ with_acc:
     // tests/artifacts/Arc4ABIMethod/contract.py:77
     // assert value
     frame_dig -3
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:78
     // assert arr
     frame_dig -1
-    byte 0x0000
+    bytec_0 // 0x0000
     !=
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:79
@@ -458,7 +457,7 @@ with_acc:
     frame_dig -2
     acct_params_get AcctMinBalance
     assert // account funded
-    int 1234
+    pushint 1234 // 1234
     +
     ==
     assert
@@ -488,17 +487,17 @@ complex_sig:
     // tests/artifacts/Arc4ABIMethod/contract.py:87
     // assert Txn.num_app_args == 4
     txn NumAppArgs
-    int 4
+    intc_2 // 4
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:88-89
     // # struct
     // assert struct1.another_struct.one == 1
     frame_dig -4
-    int 0
+    intc_1 // 0
     extract_uint16
     frame_dig -4
-    int 2
+    pushint 2 // 2
     extract_uint16
     frame_dig -4
     uncover 2
@@ -506,23 +505,20 @@ complex_sig:
     substring3
     dup
     extract 0 8 // on error: Index access is out of bounds
-    byte 0x0000000000000001
+    bytec_1 // 0x0000000000000001
     b==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:90
     // assert struct1.another_struct.two == "2"
     dup
-    int 8
+    pushint 8 // 8
     extract_uint16
-    swap
-    dup
+    dig 1
     len
-    swap
-    dup
-    uncover 3
-    uncover 3
+    dig 2
+    cover 2
     substring3
-    byte 0x000132
+    bytec_2 // 0x000132
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:91
@@ -535,35 +531,32 @@ complex_sig:
     substring3
     dup
     extract 0 8 // on error: Index access is out of bounds
-    byte 0x0000000000000001
+    bytec_1 // 0x0000000000000001
     b==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:92
     // assert struct1.another_struct_alias.two == "2"
     dup
-    int 8
+    pushint 8 // 8
     extract_uint16
-    swap
-    dup
+    dig 1
     len
-    swap
-    cover 2
     substring3
-    byte 0x000132
+    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
-    byte 0x00000000000000000000000000000003
+    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
-    byte 0x00000000000000000000000000000004
+    pushbytes 0x00000000000000000000000000000004
     b==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:96-97
@@ -572,7 +565,7 @@ complex_sig:
     frame_dig -3
     gtxns GroupIndex
     txn GroupIndex
-    int 1
+    intc_0 // 1
     -
     ==
     assert
@@ -580,7 +573,7 @@ complex_sig:
     // # acc
     // assert Txn.application_args(2) == arc4.UInt8(1).bytes  # acc array ref
     txna ApplicationArgs 2
-    byte 0x01
+    pushbytes 0x01
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:101
@@ -591,16 +584,15 @@ complex_sig:
     frame_dig -2
     acct_params_get AcctMinBalance
     assert // account funded
-    int 1234
+    pushint 1234 // 1234
     +
     ==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:102
     // assert five[0] == 5
     frame_dig -1
-    extract 2 0
-    extract 0 1 // on error: Index access is out of bounds
-    byte 0x05
+    extract 2 1
+    pushbytes 0x05
     b==
     assert
     // tests/artifacts/Arc4ABIMethod/contract.py:104
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
index e0a7cd9..2979e0e 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.arc32.json
@@ -65,8 +65,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.approval_program:
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    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@1 main_sink_route@2 main_alias_route@3 main_with_txn_route@4 main_with_asset_route@5 main_with_app_route@6 main_with_acc_route@7 main_complex_sig_route@8
    err // reject transaction

main_create_route@1:
    // tests/artifacts/Arc4ABIMethod/contract.py:26
    // @arc4.abimethod(create="require")
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    !
    assert // is creating
    callsub create
    int 1
    return

main_sink_route@2:
    // tests/artifacts/Arc4ABIMethod/contract.py:36
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    int 1
    return

main_alias_route@3:
    // tests/artifacts/Arc4ABIMethod/contract.py:41
    // @arc4.abimethod(name="alias")
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    int 1
    return

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

main_with_asset_route@5:
    // tests/artifacts/Arc4ABIMethod/contract.py:54
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    int 1
    return

main_with_app_route@6:
    // tests/artifacts/Arc4ABIMethod/contract.py:61
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    int 1
    return

main_with_acc_route@7:
    // tests/artifacts/Arc4ABIMethod/contract.py:75
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    int 1
    return

main_complex_sig_route@8:
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/Arc4ABIMethod/contract.py:25
    // class SignaturesContract(ARC4Contract):
    txna ApplicationArgs 1
    txn GroupIndex
    int 1
    -
    txna ApplicationArgs 2
    btoi
    txnas Accounts
    txna ApplicationArgs 3
    // tests/artifacts/Arc4ABIMethod/contract.py:83
    // @arc4.abimethod
    callsub complex_sig
    swap
    dup
    len
    int 4
    +
    itob
    extract 6 2
    byte 0x0004
    swap
    concat
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return


// tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.create() -> void:
create:
    // tests/artifacts/Arc4ABIMethod/contract.py:26-27
    // @arc4.abimethod(create="require")
    // def create(self) -> None:
    proto 0 0
    // tests/artifacts/Arc4ABIMethod/contract.py:28
    // app_txn = gtxn.ApplicationCallTransaction(0)
    int 0
    gtxns TypeEnum
    int 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)
    int 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
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:39
    // assert arr
    frame_dig -1
    byte 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
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:44
    // assert arr
    frame_dig -1
    byte 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
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:49
    // assert arr
    frame_dig -1
    byte 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
    int 1
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:52
    // assert pay.amount == 123
    frame_dig -2
    gtxns Amount
    int 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
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:57
    // assert arr
    frame_dig -1
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:58
    // assert asset.total == 123
    frame_dig -2
    asset_params_get AssetTotal
    assert // asset exists
    int 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
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:66
    // assert arr
    frame_dig -1
    byte 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)
    int 0
    gtxns TypeEnum
    int appl
    ==
    assert // transaction type is appl
    int 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)
    int 0
    // tests/artifacts/Arc4ABIMethod/contract.py:72
    // assert app_txn.apps(1) == app
    int 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
    byte 0x0000
    !=
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:78
    // assert arr
    frame_dig -1
    byte 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
    int 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
    int 4
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:88-89
    // # struct
    // assert struct1.another_struct.one == 1
    frame_dig -4
    int 0
    extract_uint16
    frame_dig -4
    int 2
    extract_uint16
    frame_dig -4
    uncover 2
    dig 2
    substring3
    dup
    extract 0 8 // on error: Index access is out of bounds
    byte 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:90
    // assert struct1.another_struct.two == "2"
    dup
    int 8
    extract_uint16
    swap
    dup
    len
    swap
    dup
    uncover 3
    uncover 3
    substring3
    byte 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
    byte 0x0000000000000001
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:92
    // assert struct1.another_struct_alias.two == "2"
    dup
    int 8
    extract_uint16
    swap
    dup
    len
    swap
    cover 2
    substring3
    byte 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
    byte 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
    byte 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
    int 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
    byte 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
    int 1234
    +
    ==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:102
    // assert five[0] == 5
    frame_dig -1
    extract 2 0
    extract 0 1 // on error: Index access is out of bounds
    byte 0x05
    b==
    assert
    // tests/artifacts/Arc4ABIMethod/contract.py:104
    // return struct1.another_struct.copy(), struct1.copy()
    frame_dig -4
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuQXJjNEFCSU1ldGhvZC5jb250cmFjdC5TaWduYXR1cmVzQ29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcmM0QUJJTWV0aG9kL2NvbnRyYWN0LnB5OjI1CiAgICAvLyBjbGFzcyBTaWduYXR1cmVzQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.clear.teal b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.clear.teal
index 03efbc1..a433105 100644
--- a/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.clear.teal
+++ b/tests/artifacts/Arc4ABIMethod/data/SignaturesContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Arc4ABIMethod.contract.SignaturesContract.clear_state_program:
-    // tests/artifacts/Arc4ABIMethod/contract.py:25
-    // class SignaturesContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.approval.teal b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.approval.teal
index a8fe011..a68ffac 100644
--- a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.approval.teal
+++ b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.approval.teal
@@ -1,23 +1,31 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Arc4InnerTxns.contract.Arc4InnerTxnsContract.approval_program:
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 0 1
     // tests/artifacts/Arc4InnerTxns/contract.py:4
     // class Arc4InnerTxnsContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@5
-    method "opt_in_dummy_asset(asset)void"
+    bz main_bare_routing@6
+    pushbytes 0xe2353124 // method "opt_in_dummy_asset(asset)void"
     txna ApplicationArgs 0
-    match main_opt_in_dummy_asset_route@2
-    err // reject transaction
+    match main_opt_in_dummy_asset_route@3
 
-main_opt_in_dummy_asset_route@2:
+main_after_if_else@10:
+    // tests/artifacts/Arc4InnerTxns/contract.py:4
+    // class Arc4InnerTxnsContract(ARC4Contract):
+    intc_0 // 0
+    return
+
+main_opt_in_dummy_asset_route@3:
     // tests/artifacts/Arc4InnerTxns/contract.py:5
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/Arc4InnerTxns/contract.py:4
     // class Arc4InnerTxnsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -26,19 +34,18 @@ main_opt_in_dummy_asset_route@2:
     // tests/artifacts/Arc4InnerTxns/contract.py:5
     // @arc4.abimethod
     callsub opt_in_dummy_asset
-    int 1
+    intc_1 // 1
     return
 
-main_bare_routing@5:
+main_bare_routing@6:
     // tests/artifacts/Arc4InnerTxns/contract.py:4
     // class Arc4InnerTxnsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@10
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_1 // 1
     return
 
 
@@ -64,9 +71,9 @@ opt_in_dummy_asset:
     // tests/artifacts/Arc4InnerTxns/contract.py:7-8
     // # Submit opt-in transaction: 0 asset transfer to self
     // itxn.AssetTransfer(
-    int axfer
+    pushint 4 // axfer
     itxn_field TypeEnum
-    int 0
+    intc_0 // 0
     itxn_field Fee
     // tests/artifacts/Arc4InnerTxns/contract.py:7-11
     // # Submit opt-in transaction: 0 asset transfer to self
diff --git a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc32.json b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc32.json
index 2352a6d..5344fe8 100644
--- a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc32.json
+++ b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.arc32.json
@@ -7,8 +7,8 @@
         }
     },
     "source": {
-        "approval": "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",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuQXJjNElubmVyVHhucy5jb250cmFjdC5BcmM0SW5uZXJUeG5zQ29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcmM0SW5uZXJUeG5zL2NvbnRyYWN0LnB5OjQKICAgIC8vIGNsYXNzIEFyYzRJbm5lclR4bnNDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.clear.teal b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.clear.teal
index e36943e..a433105 100644
--- a/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.clear.teal
+++ b/tests/artifacts/Arc4InnerTxns/data/Arc4InnerTxnsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Arc4InnerTxns.contract.Arc4InnerTxnsContract.clear_state_program:
-    // tests/artifacts/Arc4InnerTxns/contract.py:4
-    // class Arc4InnerTxnsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal
index e90b56d..6d74c12 100644
--- a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal
+++ b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.approval.teal
@@ -1,1283 +1,1231 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.approval_program:
+// 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@50
-    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"
+    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@2 main_verify_biguintn_uintn_eq_route@3 main_verify_uintn_biguintn_eq_route@4 main_verify_biguintn_biguintn_eq_route@5 main_verify_uintn_uintn_ne_route@6 main_verify_biguintn_uintn_ne_route@7 main_verify_uintn_biguintn_ne_route@8 main_verify_biguintn_biguintn_ne_route@9 main_verify_uintn_uintn_lt_route@10 main_verify_biguintn_uintn_lt_route@11 main_verify_uintn_biguintn_lt_route@12 main_verify_biguintn_biguintn_lt_route@13 main_verify_uintn_uintn_le_route@14 main_verify_biguintn_uintn_le_route@15 main_verify_uintn_biguintn_le_route@16 main_verify_biguintn_biguintn_le_route@17 main_verify_uintn_uintn_gt_route@18 main_verify_biguintn_uintn_gt_route@19 main_verify_uintn_biguintn_gt_route@20 main_verify_biguintn_biguintn_gt_route@21 main_verify_uintn_uintn_ge_route@22 main_verify_biguintn_uintn_ge_route@23 main_verify_uintn_biguintn_ge_route@24 main_verify_biguintn_biguintn_ge_route@25 main_verify_uintn_init_route@26 main_verify_biguintn_init_route@27 main_verify_uintn_from_bytes_route@28 main_verify_biguintn_from_bytes_route@29 main_verify_uintn_from_log_route@30 main_verify_biguintn_from_log_route@31 main_verify_ufixednxm_bytes_route@32 main_verify_bigufixednxm_bytes_route@33 main_verify_ufixednxm_from_bytes_route@34 main_verify_bigufixednxm_from_bytes_route@35 main_verify_ufixednxm_from_log_route@36 main_verify_bigufixednxm_from_log_route@37 main_verify_string_init_route@38 main_verify_string_add_route@39 main_verify_string_eq_route@40 main_verify_string_bytes_route@41 main_verify_string_from_bytes_route@42 main_verify_string_from_log_route@43 main_verify_bool_bytes_route@44 main_verify_bool_from_bytes_route@45 main_verify_bool_from_log_route@46 main_verify_emit_route@47
-    err // reject transaction
+    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_verify_uintn_uintn_eq_route@2:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
+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 NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    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
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
+    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_uintn_uintn_eq
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_emit
+    intc_0 // 1
     return
 
-main_verify_biguintn_uintn_eq_route@3:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
+main_verify_bool_from_log_route@47:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
     // @arc4.abimethod()
-    callsub verify_biguintn_uintn_eq
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_bool_from_log
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_biguintn_eq_route@4:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
+main_verify_bool_from_bytes_route@46:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
     // @arc4.abimethod()
-    callsub verify_uintn_biguintn_eq
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_biguintn_eq_route@5:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
+main_verify_bool_bytes_route@45:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
     // @arc4.abimethod()
-    callsub verify_biguintn_biguintn_eq
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_uintn_ne_route@6:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
+main_verify_string_from_log_route@44:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
     // @arc4.abimethod()
-    callsub verify_uintn_uintn_ne
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_string_from_log
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_uintn_ne_route@7:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
+main_verify_string_from_bytes_route@43:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
     // @arc4.abimethod()
-    callsub verify_biguintn_uintn_ne
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_biguintn_ne_route@8:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
+main_verify_string_bytes_route@42:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
     // @arc4.abimethod()
-    callsub verify_uintn_biguintn_ne
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_string_bytes
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_biguintn_ne_route@9:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
+main_verify_string_eq_route@41:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
     // @arc4.abimethod()
-    callsub verify_biguintn_biguintn_ne
-    byte 0x00
-    int 0
+    callsub verify_string_eq
+    bytec_1 // 0x00
+    intc_3 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_uintn_lt_route@10:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
-    // @arc4.abimethod()
+main_verify_string_add_route@40:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
+    // @arc4.abimethod
+    callsub verify_string_add
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_uintn_lt_route@11:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
-    // @arc4.abimethod()
+main_verify_string_init_route@39:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
+    // @arc4.abimethod
+    callsub verify_string_init
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_biguintn_lt_route@12:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
+main_verify_bigufixednxm_from_log_route@38:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
     // @arc4.abimethod()
-    callsub verify_uintn_biguintn_lt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_bigufixednxm_from_log
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_biguintn_lt_route@13:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
+main_verify_ufixednxm_from_log_route@37:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
     // @arc4.abimethod()
-    callsub verify_biguintn_biguintn_lt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_ufixednxm_from_log
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_uintn_le_route@14:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
+main_verify_bigufixednxm_from_bytes_route@36:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
     // @arc4.abimethod()
-    callsub verify_uintn_uintn_le
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_uintn_le_route@15:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
+main_verify_ufixednxm_from_bytes_route@35:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
     // @arc4.abimethod()
-    callsub verify_biguintn_uintn_le
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_biguintn_le_route@16:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
+main_verify_bigufixednxm_bytes_route@34:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
     // @arc4.abimethod()
-    callsub verify_uintn_biguintn_le
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_biguintn_le_route@17:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
+main_verify_ufixednxm_bytes_route@33:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
     // @arc4.abimethod()
-    callsub verify_biguintn_biguintn_le
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_uintn_gt_route@18:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
+main_verify_biguintn_from_log_route@32:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
     // @arc4.abimethod()
-    callsub verify_uintn_uintn_gt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_biguintn_from_log
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_uintn_gt_route@19:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
+main_verify_uintn_from_log_route@31:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
     // @arc4.abimethod()
-    callsub verify_biguintn_uintn_gt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uintn_from_log
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_biguintn_gt_route@20:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
+main_verify_biguintn_from_bytes_route@30:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
     // @arc4.abimethod()
-    callsub verify_uintn_biguintn_gt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_biguintn_gt_route@21:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
+main_verify_uintn_from_bytes_route@29:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
     // @arc4.abimethod()
-    callsub verify_biguintn_biguintn_gt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_uintn_ge_route@22:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
+main_verify_biguintn_init_route@28:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
     // @arc4.abimethod()
-    callsub verify_uintn_uintn_ge
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_biguintn_init
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_uintn_ge_route@23:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
+main_verify_uintn_init_route@27:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
     // @arc4.abimethod()
-    callsub verify_biguintn_uintn_ge
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uintn_init
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_biguintn_ge_route@24:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
+main_verify_biguintn_biguintn_ge_route@26:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
     // @arc4.abimethod()
-    callsub verify_uintn_biguintn_ge
-    byte 0x00
-    int 0
+    callsub verify_biguintn_biguintn_ge
+    bytec_1 // 0x00
+    intc_3 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_biguintn_ge_route@25:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
+main_verify_uintn_biguintn_ge_route@25:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
     // @arc4.abimethod()
-    callsub verify_biguintn_biguintn_ge
-    byte 0x00
-    int 0
+    callsub verify_uintn_biguintn_ge
+    bytec_1 // 0x00
+    intc_3 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_init_route@26:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
+main_verify_biguintn_uintn_ge_route@24:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
     // @arc4.abimethod()
-    callsub verify_uintn_init
-    byte 0x151f7c75
+    callsub verify_biguintn_uintn_ge
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_init_route@27:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
+main_verify_uintn_uintn_ge_route@23:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
     // @arc4.abimethod()
-    callsub verify_biguintn_init
-    byte 0x151f7c75
+    callsub verify_uintn_uintn_ge
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_from_bytes_route@28:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
+main_verify_biguintn_biguintn_gt_route@22:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
     // @arc4.abimethod()
-    callsub verify_uintn_from_bytes
-    byte 0x151f7c75
+    callsub verify_biguintn_biguintn_gt
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_from_bytes_route@29:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
+main_verify_uintn_biguintn_gt_route@21:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
     // @arc4.abimethod()
-    callsub verify_biguintn_from_bytes
-    byte 0x151f7c75
+    callsub verify_uintn_biguintn_gt
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uintn_from_log_route@30:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
+main_verify_biguintn_uintn_gt_route@20:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
     // @arc4.abimethod()
-    callsub verify_uintn_from_log
-    byte 0x151f7c75
+    callsub verify_biguintn_uintn_gt
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguintn_from_log_route@31:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
+main_verify_uintn_uintn_gt_route@19:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
     // @arc4.abimethod()
-    callsub verify_biguintn_from_log
-    byte 0x151f7c75
+    callsub verify_uintn_uintn_gt
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_ufixednxm_bytes_route@32:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
+main_verify_biguintn_biguintn_le_route@18:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
     // @arc4.abimethod()
-    callsub verify_ufixednxm_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_biguintn_biguintn_le
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bigufixednxm_bytes_route@33:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
+main_verify_uintn_biguintn_le_route@17:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
     // @arc4.abimethod()
-    callsub verify_bigufixednxm_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_uintn_biguintn_le
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_ufixednxm_from_bytes_route@34:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
+main_verify_biguintn_uintn_le_route@16:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
     // @arc4.abimethod()
-    callsub verify_ufixednxm_from_bytes
-    byte 0x151f7c75
+    callsub verify_biguintn_uintn_le
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bigufixednxm_from_bytes_route@35:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
+main_verify_uintn_uintn_le_route@15:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
     // @arc4.abimethod()
-    callsub verify_bigufixednxm_from_bytes
-    byte 0x151f7c75
+    callsub verify_uintn_uintn_le
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_ufixednxm_from_log_route@36:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
+main_verify_biguintn_biguintn_lt_route@14:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
     // @arc4.abimethod()
-    callsub verify_ufixednxm_from_log
-    byte 0x151f7c75
+    callsub verify_biguintn_biguintn_lt
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bigufixednxm_from_log_route@37:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
+main_verify_uintn_biguintn_lt_route@13:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
     // @arc4.abimethod()
-    callsub verify_bigufixednxm_from_log
-    byte 0x151f7c75
+    callsub verify_uintn_biguintn_lt
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_init_route@38:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
-    // @arc4.abimethod
+main_verify_biguintn_uintn_lt_route@12:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    byte 0x151f7c75
+    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
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_add_route@39:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
-    // @arc4.abimethod
+main_verify_uintn_uintn_lt_route@11:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
-    // @arc4.abimethod
-    callsub verify_string_add
-    byte 0x151f7c75
+    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
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_eq_route@40:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
+main_verify_biguintn_biguintn_ne_route@10:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
     // @arc4.abimethod()
-    callsub verify_string_eq
-    byte 0x00
-    int 0
+    callsub verify_biguintn_biguintn_ne
+    bytec_1 // 0x00
+    intc_3 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_bytes_route@41:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
+main_verify_uintn_biguintn_ne_route@9:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
     // @arc4.abimethod()
-    callsub verify_string_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_uintn_biguintn_ne
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_from_bytes_route@42:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
+main_verify_biguintn_uintn_ne_route@8:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
     // @arc4.abimethod()
-    callsub verify_string_from_bytes
-    byte 0x151f7c75
+    callsub verify_biguintn_uintn_ne
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_from_log_route@43:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
+main_verify_uintn_uintn_ne_route@7:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
     // @arc4.abimethod()
-    callsub verify_string_from_log
-    byte 0x151f7c75
+    callsub verify_uintn_uintn_ne
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bool_bytes_route@44:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
+main_verify_biguintn_biguintn_eq_route@6:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
     // @arc4.abimethod()
-    callsub verify_bool_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_biguintn_biguintn_eq
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bool_from_bytes_route@45:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
+main_verify_uintn_biguintn_eq_route@5:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
     // @arc4.abimethod()
-    callsub verify_bool_from_bytes
-    byte 0x151f7c75
+    callsub verify_uintn_biguintn_eq
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bool_from_log_route@46:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
+main_verify_biguintn_uintn_eq_route@4:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
     // @arc4.abimethod()
-    callsub verify_bool_from_log
-    byte 0x151f7c75
+    callsub verify_biguintn_uintn_eq
+    bytec_1 // 0x00
+    intc_3 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_emit_route@47:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
+main_verify_uintn_uintn_eq_route@3:
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
-    int 0
-    extract_uint16
-    swap
-    dup
-    int 2
-    extract_uint16
-    swap
-    cover 2
-    substring3
-    extract 2 0
-    txna ApplicationArgs 15
-    dup
-    int 2
-    extract_uint16
-    swap
-    dup
-    len
-    swap
-    cover 2
-    substring3
+    txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
+    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
     // @arc4.abimethod()
-    callsub verify_emit
-    int 1
+    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@50:
+main_bare_routing@51:
     // tests/artifacts/Arc4PrimitiveOps/contract.py:6
     // class Arc4PrimitiveOpsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@55
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
@@ -1291,21 +1239,21 @@ verify_uintn_uintn_eq:
     // return arc4.UInt64(a_biguint) == arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b==
     retsub
@@ -1321,19 +1269,19 @@ verify_biguintn_uintn_eq:
     // return arc4.UInt512(a_biguint) == arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -1
     b|
@@ -1351,19 +1299,19 @@ verify_uintn_biguintn_eq:
     // return arc4.UInt64(a_biguint) == arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -1
     b|
@@ -1381,21 +1329,21 @@ verify_biguintn_biguintn_eq:
     // return arc4.UInt512(a_biguint) == arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b==
     retsub
@@ -1411,21 +1359,21 @@ verify_uintn_uintn_ne:
     // return arc4.UInt64(a_biguint) != arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b!=
     retsub
@@ -1441,19 +1389,19 @@ verify_biguintn_uintn_ne:
     // return arc4.UInt512(a_biguint) != arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -1
     b|
@@ -1471,19 +1419,19 @@ verify_uintn_biguintn_ne:
     // return arc4.UInt64(a_biguint) != arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -1
     b|
@@ -1501,21 +1449,21 @@ verify_biguintn_biguintn_ne:
     // return arc4.UInt512(a_biguint) != arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b!=
     retsub
@@ -1531,21 +1479,21 @@ verify_uintn_uintn_lt:
     // return arc4.UInt64(a_biguint) < arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b<
     retsub
@@ -1561,19 +1509,19 @@ verify_biguintn_uintn_lt:
     // return arc4.UInt512(a_biguint) < arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -1
     b|
@@ -1591,19 +1539,19 @@ verify_uintn_biguintn_lt:
     // return arc4.UInt64(a_biguint) < arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -1
     b|
@@ -1621,21 +1569,21 @@ verify_biguintn_biguintn_lt:
     // return arc4.UInt512(a_biguint) < arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b<
     retsub
@@ -1651,21 +1599,21 @@ verify_uintn_uintn_le:
     // return arc4.UInt64(a_biguint) <= arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b<=
     retsub
@@ -1681,19 +1629,19 @@ verify_biguintn_uintn_le:
     // return arc4.UInt512(a_biguint) <= arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -1
     b|
@@ -1711,19 +1659,19 @@ verify_uintn_biguintn_le:
     // return arc4.UInt64(a_biguint) <= arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -1
     b|
@@ -1741,21 +1689,21 @@ verify_biguintn_biguintn_le:
     // return arc4.UInt512(a_biguint) <= arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b<=
     retsub
@@ -1771,21 +1719,21 @@ verify_uintn_uintn_gt:
     // return arc4.UInt64(a_biguint) > arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b>
     retsub
@@ -1801,19 +1749,19 @@ verify_biguintn_uintn_gt:
     // return arc4.UInt512(a_biguint) > arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -1
     b|
@@ -1831,19 +1779,19 @@ verify_uintn_biguintn_gt:
     // return arc4.UInt64(a_biguint) > arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -1
     b|
@@ -1861,21 +1809,21 @@ verify_biguintn_biguintn_gt:
     // return arc4.UInt512(a_biguint) > arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b>
     retsub
@@ -1891,21 +1839,21 @@ verify_uintn_uintn_ge:
     // return arc4.UInt64(a_biguint) >= arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b>=
     retsub
@@ -1921,19 +1869,19 @@ verify_biguintn_uintn_ge:
     // return arc4.UInt512(a_biguint) >= arc4.UInt64(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -1
     b|
@@ -1951,19 +1899,19 @@ verify_uintn_biguintn_ge:
     // return arc4.UInt64(a_biguint) >= arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 8
+    intc_1 // 8
     <=
     assert // overflow
-    int 8
+    intc_1 // 8
     bzero
     frame_dig -2
     b|
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -1
     b|
@@ -1981,21 +1929,21 @@ verify_biguintn_biguintn_ge:
     // return arc4.UInt512(a_biguint) >= arc4.UInt512(b_biguint)
     frame_dig -2
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
-    int 64
+    intc_2 // 64
     bzero
     frame_dig -2
     dig 1
     b|
-    swap
     frame_dig -1
     len
-    int 64
+    intc_2 // 64
     <=
     assert // overflow
     frame_dig -1
+    uncover 2
     b|
     b>=
     retsub
@@ -2011,10 +1959,10 @@ verify_uintn_init:
     // return arc4.UInt32(a_biguint)
     frame_dig -1
     len
-    int 4
+    pushint 4 // 4
     <=
     assert // overflow
-    int 4
+    pushint 4 // 4
     bzero
     frame_dig -1
     b|
@@ -2031,40 +1979,16 @@ verify_biguintn_init:
     // return arc4.UInt256(a_biguint)
     frame_dig -1
     len
-    int 32
+    pushint 32 // 32
     <=
     assert // overflow
-    int 32
+    pushint 32 // 32
     bzero
     frame_dig -1
     b|
     retsub
 
 
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_bytes(a: bytes) -> bytes:
-verify_uintn_from_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:161-162
-    // @arc4.abimethod()
-    // def verify_uintn_from_bytes(self, a: Bytes) -> arc4.UInt32:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:163
-    // return arc4.UInt32.from_bytes(a)
-    frame_dig -1
-    retsub
-
-
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_bytes(a: bytes) -> bytes:
-verify_biguintn_from_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:165-166
-    // @arc4.abimethod()
-    // def verify_biguintn_from_bytes(self, a: Bytes) -> arc4.UInt256:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:167
-    // return arc4.UInt256.from_bytes(a)
-    frame_dig -1
-    retsub
-
-
 // tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_log(a: bytes) -> bytes:
 verify_uintn_from_log:
     // tests/artifacts/Arc4PrimitiveOps/contract.py:169-170
@@ -2077,7 +2001,7 @@ verify_uintn_from_log:
     extract 4 0
     frame_dig -1
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     retsub
@@ -2095,68 +2019,12 @@ verify_biguintn_from_log:
     extract 4 0
     frame_dig -1
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     retsub
 
 
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_bytes(a: bytes) -> bytes:
-verify_ufixednxm_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:177-180
-    // @arc4.abimethod()
-    // def verify_ufixednxm_bytes(
-    //     self, a: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]
-    // ) -> Bytes:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:181
-    // return a.bytes
-    frame_dig -1
-    retsub
-
-
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_bytes(a: bytes) -> bytes:
-verify_bigufixednxm_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:183-186
-    // @arc4.abimethod()
-    // def verify_bigufixednxm_bytes(
-    //     self, a: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]
-    // ) -> Bytes:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:187
-    // return a.bytes
-    frame_dig -1
-    retsub
-
-
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_bytes(a: bytes) -> bytes:
-verify_ufixednxm_from_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:189-192
-    // @arc4.abimethod()
-    // def verify_ufixednxm_from_bytes(
-    //     self, a: Bytes
-    // ) -> arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:193
-    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_bytes(a)
-    frame_dig -1
-    retsub
-
-
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_bytes(a: bytes) -> bytes:
-verify_bigufixednxm_from_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:195-198
-    // @arc4.abimethod()
-    // def verify_bigufixednxm_from_bytes(
-    //     self, a: Bytes
-    // ) -> arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:199
-    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_bytes(a)
-    frame_dig -1
-    retsub
-
-
 // tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_log(a: bytes) -> bytes:
 verify_ufixednxm_from_log:
     // tests/artifacts/Arc4PrimitiveOps/contract.py:201-204
@@ -2171,7 +2039,7 @@ verify_ufixednxm_from_log:
     extract 4 0
     frame_dig -1
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     retsub
@@ -2191,7 +2059,7 @@ verify_bigufixednxm_from_log:
     extract 4 0
     frame_dig -1
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     retsub
@@ -2205,7 +2073,7 @@ verify_string_init:
     proto 1 1
     // tests/artifacts/Arc4PrimitiveOps/contract.py:215
     // result = arc4.String(String("Hello, ") + a)
-    byte "Hello, "
+    pushbytes "Hello, "
     frame_dig -1
     concat
     dup
@@ -2276,18 +2144,6 @@ verify_string_bytes:
     retsub
 
 
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_bytes(a: bytes) -> bytes:
-verify_string_from_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:232-233
-    // @arc4.abimethod()
-    // def verify_string_from_bytes(self, a: Bytes) -> arc4.String:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:234
-    // return arc4.String.from_bytes(a)
-    frame_dig -1
-    retsub
-
-
 // tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_string_from_log(a: bytes) -> bytes:
 verify_string_from_log:
     // tests/artifacts/Arc4PrimitiveOps/contract.py:236-237
@@ -2300,36 +2156,12 @@ verify_string_from_log:
     extract 4 0
     frame_dig -1
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     retsub
 
 
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_bytes(a: bytes) -> bytes:
-verify_bool_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:240-241
-    // @arc4.abimethod()
-    // def verify_bool_bytes(self, a: arc4.Bool) -> Bytes:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:242
-    // return a.bytes
-    frame_dig -1
-    retsub
-
-
-// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_bytes(a: bytes) -> bytes:
-verify_bool_from_bytes:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:244-245
-    // @arc4.abimethod()
-    // def verify_bool_from_bytes(self, a: Bytes) -> arc4.Bool:
-    proto 1 1
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:246
-    // return arc4.Bool.from_bytes(a)
-    frame_dig -1
-    retsub
-
-
 // tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_log(a: bytes) -> bytes:
 verify_bool_from_log:
     // tests/artifacts/Arc4PrimitiveOps/contract.py:248-249
@@ -2342,7 +2174,7 @@ verify_bool_from_log:
     extract 4 0
     frame_dig -1
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     retsub
@@ -2385,11 +2217,11 @@ verify_emit:
     concat
     frame_dig -3
     concat
-    byte 0x0054
+    pushbytes 0x0054
     concat
     frame_dig -2
     len
-    int 84
+    pushint 84 // 84
     dig 1
     +
     itob
@@ -2401,7 +2233,7 @@ verify_emit:
     concat
     frame_dig -1
     concat
-    method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
+    pushbytes 0x66bb0333 // method "SwappedArc4(uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
     swap
     concat
     log
@@ -2427,9 +2259,9 @@ verify_emit:
     // )
     frame_dig -16
     len
-    int 173
+    pushint 173 // 173
     +
-    byte 0x00ad
+    pushbytes 0x00ad
     frame_dig -15
     concat
     frame_dig -14
@@ -2451,9 +2283,9 @@ verify_emit:
     itob
     extract 6 2
     concat
-    swap
     frame_dig -10
     len
+    uncover 2
     +
     dup
     itob
@@ -2500,7 +2332,7 @@ verify_emit:
     concat
     frame_dig -1
     concat
-    method "Swapped(string,uint512,uint64,byte[],uint64,bool,byte[],string,uint64,uint256,ufixed32x8,ufixed256x16,bool,uint8[3],uint16[],(uint32,uint64,string))"
+    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
diff --git a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json
index 084cf1d..9e5a5a0 100644
--- a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json
+++ b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.arc32.json
@@ -232,8 +232,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.approval_program:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@50
    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@2 main_verify_biguintn_uintn_eq_route@3 main_verify_uintn_biguintn_eq_route@4 main_verify_biguintn_biguintn_eq_route@5 main_verify_uintn_uintn_ne_route@6 main_verify_biguintn_uintn_ne_route@7 main_verify_uintn_biguintn_ne_route@8 main_verify_biguintn_biguintn_ne_route@9 main_verify_uintn_uintn_lt_route@10 main_verify_biguintn_uintn_lt_route@11 main_verify_uintn_biguintn_lt_route@12 main_verify_biguintn_biguintn_lt_route@13 main_verify_uintn_uintn_le_route@14 main_verify_biguintn_uintn_le_route@15 main_verify_uintn_biguintn_le_route@16 main_verify_biguintn_biguintn_le_route@17 main_verify_uintn_uintn_gt_route@18 main_verify_biguintn_uintn_gt_route@19 main_verify_uintn_biguintn_gt_route@20 main_verify_biguintn_biguintn_gt_route@21 main_verify_uintn_uintn_ge_route@22 main_verify_biguintn_uintn_ge_route@23 main_verify_uintn_biguintn_ge_route@24 main_verify_biguintn_biguintn_ge_route@25 main_verify_uintn_init_route@26 main_verify_biguintn_init_route@27 main_verify_uintn_from_bytes_route@28 main_verify_biguintn_from_bytes_route@29 main_verify_uintn_from_log_route@30 main_verify_biguintn_from_log_route@31 main_verify_ufixednxm_bytes_route@32 main_verify_bigufixednxm_bytes_route@33 main_verify_ufixednxm_from_bytes_route@34 main_verify_bigufixednxm_from_bytes_route@35 main_verify_ufixednxm_from_log_route@36 main_verify_bigufixednxm_from_log_route@37 main_verify_string_init_route@38 main_verify_string_add_route@39 main_verify_string_eq_route@40 main_verify_string_bytes_route@41 main_verify_string_from_bytes_route@42 main_verify_string_from_log_route@43 main_verify_bool_bytes_route@44 main_verify_bool_from_bytes_route@45 main_verify_bool_from_log_route@46 main_verify_emit_route@47
    err // reject transaction

main_verify_uintn_uintn_eq_route@2:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_uintn_eq_route@3:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:13
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_biguintn_eq_route@4:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:19
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_biguintn_eq_route@5:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_uintn_ne_route@6:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_uintn_ne_route@7:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_biguintn_ne_route@8:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:43
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_biguintn_ne_route@9:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:49
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_uintn_lt_route@10:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_uintn_lt_route@11:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:61
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_biguintn_lt_route@12:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_biguintn_lt_route@13:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:73
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_uintn_le_route@14:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:79
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_uintn_le_route@15:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:85
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_biguintn_le_route@16:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_biguintn_le_route@17:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_uintn_gt_route@18:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_uintn_gt_route@19:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:109
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_biguintn_gt_route@20:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:115
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_biguintn_gt_route@21:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_uintn_ge_route@22:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_uintn_ge_route@23:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:133
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_biguintn_ge_route@24:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:139
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_biguintn_ge_route@25:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:145
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_init_route@26:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_init_route@27:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_from_bytes_route@28:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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()
    callsub verify_uintn_from_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_from_bytes_route@29:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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()
    callsub verify_biguintn_from_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uintn_from_log_route@30:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguintn_from_log_route@31:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:173
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ufixednxm_bytes_route@32:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177
    // @arc4.abimethod()
    callsub verify_ufixednxm_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bigufixednxm_bytes_route@33:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183
    // @arc4.abimethod()
    callsub verify_bigufixednxm_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ufixednxm_from_bytes_route@34:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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()
    callsub verify_ufixednxm_from_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bigufixednxm_from_bytes_route@35:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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()
    callsub verify_bigufixednxm_from_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ufixednxm_from_log_route@36:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bigufixednxm_from_log_route@37:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_init_route@38:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:213
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_add_route@39:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:218
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_eq_route@40:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_bytes_route@41:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_from_bytes_route@42:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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()
    callsub verify_string_from_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_from_log_route@43:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:236
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bool_bytes_route@44:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    callsub verify_bool_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bool_from_bytes_route@45:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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()
    callsub verify_bool_from_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bool_from_log_route@46:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:248
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_emit_route@47:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    int 0
    extract_uint16
    swap
    dup
    int 2
    extract_uint16
    swap
    cover 2
    substring3
    extract 2 0
    txna ApplicationArgs 15
    dup
    int 2
    extract_uint16
    swap
    dup
    len
    swap
    cover 2
    substring3
    extract 2 0
    // tests/artifacts/Arc4PrimitiveOps/contract.py:252
    // @arc4.abimethod()
    callsub verify_emit
    int 1
    return

main_bare_routing@50:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
    // class Arc4PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    frame_dig -1
    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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    int 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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    frame_dig -1
    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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    frame_dig -1
    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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    int 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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    frame_dig -1
    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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    frame_dig -1
    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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    int 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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    frame_dig -1
    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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    frame_dig -1
    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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    int 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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    frame_dig -1
    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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    frame_dig -1
    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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    int 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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    frame_dig -1
    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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    frame_dig -1
    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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 8
    <=
    assert // overflow
    int 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
    int 8
    <=
    assert // overflow
    int 8
    bzero
    frame_dig -2
    b|
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    int 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
    int 64
    <=
    assert // overflow
    int 64
    bzero
    frame_dig -2
    dig 1
    b|
    swap
    frame_dig -1
    len
    int 64
    <=
    assert // overflow
    frame_dig -1
    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
    int 4
    <=
    assert // overflow
    int 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
    int 32
    <=
    assert // overflow
    int 32
    bzero
    frame_dig -1
    b|
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_uintn_from_bytes(a: bytes) -> bytes:
verify_uintn_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:161-162
    // @arc4.abimethod()
    // def verify_uintn_from_bytes(self, a: Bytes) -> arc4.UInt32:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:163
    // return arc4.UInt32.from_bytes(a)
    frame_dig -1
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_biguintn_from_bytes(a: bytes) -> bytes:
verify_biguintn_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:165-166
    // @arc4.abimethod()
    // def verify_biguintn_from_bytes(self, a: Bytes) -> arc4.UInt256:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:167
    // return arc4.UInt256.from_bytes(a)
    frame_dig -1
    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
    byte 0x151f7c75
    ==
    assert // ARC4 prefix is valid
    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
    byte 0x151f7c75
    ==
    assert // ARC4 prefix is valid
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_bytes(a: bytes) -> bytes:
verify_ufixednxm_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:177-180
    // @arc4.abimethod()
    // def verify_ufixednxm_bytes(
    //     self, a: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]
    // ) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:181
    // return a.bytes
    frame_dig -1
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_bytes(a: bytes) -> bytes:
verify_bigufixednxm_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:183-186
    // @arc4.abimethod()
    // def verify_bigufixednxm_bytes(
    //     self, a: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]
    // ) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:187
    // return a.bytes
    frame_dig -1
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_ufixednxm_from_bytes(a: bytes) -> bytes:
verify_ufixednxm_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:189-192
    // @arc4.abimethod()
    // def verify_ufixednxm_from_bytes(
    //     self, a: Bytes
    // ) -> arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:193
    // return arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]].from_bytes(a)
    frame_dig -1
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bigufixednxm_from_bytes(a: bytes) -> bytes:
verify_bigufixednxm_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:195-198
    // @arc4.abimethod()
    // def verify_bigufixednxm_from_bytes(
    //     self, a: Bytes
    // ) -> arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]]:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:199
    // return arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]].from_bytes(a)
    frame_dig -1
    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
    byte 0x151f7c75
    ==
    assert // ARC4 prefix is valid
    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
    byte 0x151f7c75
    ==
    assert // ARC4 prefix is valid
    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)
    byte "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_bytes(a: bytes) -> bytes:
verify_string_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:232-233
    // @arc4.abimethod()
    // def verify_string_from_bytes(self, a: Bytes) -> arc4.String:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:234
    // return arc4.String.from_bytes(a)
    frame_dig -1
    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
    byte 0x151f7c75
    ==
    assert // ARC4 prefix is valid
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_bytes(a: bytes) -> bytes:
verify_bool_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:240-241
    // @arc4.abimethod()
    // def verify_bool_bytes(self, a: arc4.Bool) -> Bytes:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:242
    // return a.bytes
    frame_dig -1
    retsub


// tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.verify_bool_from_bytes(a: bytes) -> bytes:
verify_bool_from_bytes:
    // tests/artifacts/Arc4PrimitiveOps/contract.py:244-245
    // @arc4.abimethod()
    // def verify_bool_from_bytes(self, a: Bytes) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/Arc4PrimitiveOps/contract.py:246
    // return arc4.Bool.from_bytes(a)
    frame_dig -1
    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
    byte 0x151f7c75
    ==
    assert // ARC4 prefix is valid
    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
    byte 0x0054
    concat
    frame_dig -2
    len
    int 84
    dig 1
    +
    itob
    extract 6 2
    uncover 2
    swap
    concat
    frame_dig -2
    concat
    frame_dig -1
    concat
    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
    int 173
    +
    byte 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
    swap
    frame_dig -10
    len
    +
    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
    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": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuQXJjNFByaW1pdGl2ZU9wcy5jb250cmFjdC5BcmM0UHJpbWl0aXZlT3BzQ29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9BcmM0UHJpbWl0aXZlT3BzL2NvbnRyYWN0LnB5OjYKICAgIC8vIGNsYXNzIEFyYzRQcmltaXRpdmVPcHNDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "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 // ARC4 prefix is valid
    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 // ARC4 prefix is valid
    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 // ARC4 prefix is valid
    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 // ARC4 prefix is valid
    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 // ARC4 prefix is valid
    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 // ARC4 prefix is valid
    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": {
         "global": {
diff --git a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.clear.teal b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.clear.teal
index f5cc48f..a433105 100644
--- a/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.clear.teal
+++ b/tests/artifacts/Arc4PrimitiveOps/data/Arc4PrimitiveOpsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Arc4PrimitiveOps.contract.Arc4PrimitiveOpsContract.clear_state_program:
-    // tests/artifacts/Arc4PrimitiveOps/contract.py:6
-    // class Arc4PrimitiveOpsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/BoxContract/data/BoxContract.approval.teal b/tests/artifacts/BoxContract/data/BoxContract.approval.teal
index ad0f79d..a53c4c2 100644
--- a/tests/artifacts/BoxContract/data/BoxContract.approval.teal
+++ b/tests/artifacts/BoxContract/data/BoxContract.approval.teal
@@ -1,83 +1,78 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.BoxContract.contract.BoxContract.approval_program:
+// tests.artifacts.BoxContract.contract.BoxContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    intcblock 1
+    bytecblock 0x6f6361 0x74786e
     // tests/artifacts/BoxContract/contract.py:4
     // class BoxContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@6
-    method "store_enums()void"
-    method "read_enums()(uint64,uint64)"
+    bz main_bare_routing@7
+    pushbytess 0xf26c6d42 0xef186cf7 // method "store_enums()void", method "read_enums()(uint64,uint64)"
     txna ApplicationArgs 0
-    match main_store_enums_route@2 main_read_enums_route@3
-    err // reject transaction
+    match main_store_enums_route@5 main_read_enums_route@6
 
-main_store_enums_route@2:
-    // tests/artifacts/BoxContract/contract.py:9
-    // @arc4.abimethod()
-    txn OnCompletion
-    !
-    assert // OnCompletion is NoOp
-    txn ApplicationID
-    assert // is not creating
-    callsub store_enums
-    int 1
+main_after_if_else@9:
+    // tests/artifacts/BoxContract/contract.py:4
+    // class BoxContract(ARC4Contract):
+    pushint 0 // 0
     return
 
-main_read_enums_route@3:
+main_read_enums_route@6:
     // tests/artifacts/BoxContract/contract.py:14
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     callsub read_enums
-    byte 0x151f7c75
+    pushbytes 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@6:
+main_store_enums_route@5:
+    // tests/artifacts/BoxContract/contract.py:9
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub store_enums
+    intc_0 // 1
+    return
+
+main_bare_routing@7:
     // tests/artifacts/BoxContract/contract.py:4
     // class BoxContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@9
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.BoxContract.contract.BoxContract.store_enums() -> void:
 store_enums:
-    // tests/artifacts/BoxContract/contract.py:9-10
-    // @arc4.abimethod()
-    // def store_enums(self) -> None:
-    proto 0 0
     // tests/artifacts/BoxContract/contract.py:11
     // self.oca.value = OnCompleteAction.OptIn
-    int OptIn
+    intc_0 // OptIn
     itob
-    // tests/artifacts/BoxContract/contract.py:6
-    // self.oca = Box(OnCompleteAction)
-    byte "oca"
-    // tests/artifacts/BoxContract/contract.py:11
-    // self.oca.value = OnCompleteAction.OptIn
+    bytec_0 // "oca"
     swap
     box_put
     // tests/artifacts/BoxContract/contract.py:12
     // self.txn.value = TransactionType.ApplicationCall
-    int appl
+    pushint 6 // appl
     itob
-    // tests/artifacts/BoxContract/contract.py:7
-    // self.txn = Box(TransactionType)
-    byte "txn"
-    // tests/artifacts/BoxContract/contract.py:12
-    // self.txn.value = TransactionType.ApplicationCall
+    bytec_1 // "txn"
     swap
     box_put
     retsub
@@ -85,20 +80,12 @@ store_enums:
 
 // tests.artifacts.BoxContract.contract.BoxContract.read_enums() -> bytes:
 read_enums:
-    // tests/artifacts/BoxContract/contract.py:14-15
-    // @arc4.abimethod()
-    // def read_enums(self) -> arc4.Tuple[arc4.UInt64, arc4.UInt64]:
-    proto 0 1
     // tests/artifacts/BoxContract/contract.py:16
     // assert op.Box.get(b"oca")[0] == op.itob(self.oca.value)
-    byte 0x6f6361
+    bytec_0 // 0x6f6361
     box_get
     pop
-    // tests/artifacts/BoxContract/contract.py:6
-    // self.oca = Box(OnCompleteAction)
-    byte "oca"
-    // tests/artifacts/BoxContract/contract.py:16
-    // assert op.Box.get(b"oca")[0] == op.itob(self.oca.value)
+    bytec_0 // "oca"
     box_get
     swap
     btoi
@@ -109,14 +96,10 @@ read_enums:
     assert
     // tests/artifacts/BoxContract/contract.py:17
     // assert op.Box.get(b"txn")[0] == op.itob(self.txn.value)
-    byte 0x74786e
+    bytec_1 // 0x74786e
     box_get
     pop
-    // tests/artifacts/BoxContract/contract.py:7
-    // self.txn = Box(TransactionType)
-    byte "txn"
-    // tests/artifacts/BoxContract/contract.py:17
-    // assert op.Box.get(b"txn")[0] == op.itob(self.txn.value)
+    bytec_1 // "txn"
     box_get
     swap
     btoi
@@ -125,22 +108,16 @@ read_enums:
     itob
     ==
     assert
-    // tests/artifacts/BoxContract/contract.py:6
-    // self.oca = Box(OnCompleteAction)
-    byte "oca"
     // tests/artifacts/BoxContract/contract.py:19
     // return arc4.Tuple((arc4.UInt64(self.oca.value), arc4.UInt64(self.txn.value)))
+    bytec_0 // "oca"
     box_get
     swap
     btoi
     swap
     assert // check self.oca exists
     itob
-    // tests/artifacts/BoxContract/contract.py:7
-    // self.txn = Box(TransactionType)
-    byte "txn"
-    // tests/artifacts/BoxContract/contract.py:19
-    // return arc4.Tuple((arc4.UInt64(self.oca.value), arc4.UInt64(self.txn.value)))
+    bytec_1 // "txn"
     box_get
     swap
     btoi
diff --git a/tests/artifacts/BoxContract/data/BoxContract.arc32.json b/tests/artifacts/BoxContract/data/BoxContract.arc32.json
index 4e43a17..07697a8 100644
--- a/tests/artifacts/BoxContract/data/BoxContract.arc32.json
+++ b/tests/artifacts/BoxContract/data/BoxContract.arc32.json
@@ -12,8 +12,8 @@
         }
     },
     "source": {
-        "approval": "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",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuQm94Q29udHJhY3QuY29udHJhY3QuQm94Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9Cb3hDb250cmFjdC9jb250cmFjdC5weTo0CiAgICAvLyBjbGFzcyBCb3hDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/BoxContract/data/BoxContract.clear.teal b/tests/artifacts/BoxContract/data/BoxContract.clear.teal
index 27c12e7..a433105 100644
--- a/tests/artifacts/BoxContract/data/BoxContract.clear.teal
+++ b/tests/artifacts/BoxContract/data/BoxContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.BoxContract.contract.BoxContract.clear_state_program:
-    // tests/artifacts/BoxContract/contract.py:4
-    // class BoxContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/Contains/data/MyContract.approval.teal b/tests/artifacts/Contains/data/MyContract.approval.teal
index 9da7415..58b9125 100644
--- a/tests/artifacts/Contains/data/MyContract.approval.teal
+++ b/tests/artifacts/Contains/data/MyContract.approval.teal
@@ -1,27 +1,31 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Contains.contract.MyContract.approval_program:
+// tests.artifacts.Contains.contract.MyContract.approval_program() -> uint64:
+main:
+    intcblock 0 1 10 15
+    bytecblock 0x66697665 0x68656c6c6f 0x626f6e6a6f7572 0x1d65e22bcbbf 0x07acf5cae41e
     // tests/artifacts/Contains/contract.py:10
     // one_true = self.is_in_tuple_1(UInt64(10), (UInt64(10), not_ten, Bytes(b"five")))
-    int 10
+    intc_2 // 10
     dup
     // tests/artifacts/Contains/contract.py:8
     // not_ten = UInt64(15)
-    int 15
+    intc_3 // 15
     // tests/artifacts/Contains/contract.py:10
     // one_true = self.is_in_tuple_1(UInt64(10), (UInt64(10), not_ten, Bytes(b"five")))
-    byte 0x66697665
+    bytec_0 // 0x66697665
     callsub is_in_tuple_1
     // tests/artifacts/Contains/contract.py:11
     // one_false = self.is_in_tuple_1(UInt64(5), (UInt64(10), not_ten, Bytes(b"five")))
-    int 5
-    int 10
+    pushint 5 // 5
+    intc_2 // 10
     // tests/artifacts/Contains/contract.py:8
     // not_ten = UInt64(15)
-    int 15
+    intc_3 // 15
     // tests/artifacts/Contains/contract.py:11
     // one_false = self.is_in_tuple_1(UInt64(5), (UInt64(10), not_ten, Bytes(b"five")))
-    byte 0x66697665
+    bytec_0 // 0x66697665
     callsub is_in_tuple_1
     // tests/artifacts/Contains/contract.py:12
     // assert one_true, "Should be true"
@@ -33,10 +37,10 @@ tests.artifacts.Contains.contract.MyContract.approval_program:
     assert // Should be false
     // tests/artifacts/Contains/contract.py:16
     // Bytes(b"hello"), (Bytes(b"hello"), UInt64(0), Bytes(b"bonjour"))
-    byte 0x68656c6c6f
+    bytec_1 // 0x68656c6c6f
     dup
-    int 0
-    byte 0x626f6e6a6f7572
+    intc_0 // 0
+    bytec_2 // 0x626f6e6a6f7572
     // tests/artifacts/Contains/contract.py:15-17
     // two_true = self.is_in_tuple_2(
     //     Bytes(b"hello"), (Bytes(b"hello"), UInt64(0), Bytes(b"bonjour"))
@@ -44,10 +48,10 @@ tests.artifacts.Contains.contract.MyContract.approval_program:
     callsub is_in_tuple_2
     // tests/artifacts/Contains/contract.py:19
     // Bytes(b"ciao"), (Bytes(b"hello"), UInt64(0), Bytes(b"bonjour"))
-    byte 0x6369616f
-    byte 0x68656c6c6f
-    int 0
-    byte 0x626f6e6a6f7572
+    pushbytes 0x6369616f
+    bytec_1 // 0x68656c6c6f
+    intc_0 // 0
+    bytec_2 // 0x626f6e6a6f7572
     // tests/artifacts/Contains/contract.py:18-20
     // two_false = self.is_in_tuple_2(
     //     Bytes(b"ciao"), (Bytes(b"hello"), UInt64(0), Bytes(b"bonjour"))
@@ -63,9 +67,9 @@ tests.artifacts.Contains.contract.MyContract.approval_program:
     assert // Should be false
     // tests/artifacts/Contains/contract.py:25
     // BigUInt(32323423423423), (BigUInt(32323423423423), BigUInt(8439439483934))
-    byte 0x1d65e22bcbbf
+    bytec_3 // 0x1d65e22bcbbf
     dup
-    byte 0x07acf5cae41e
+    bytec 4 // 0x07acf5cae41e
     // tests/artifacts/Contains/contract.py:24-26
     // three_true = self.is_in_tuple_3(
     //     BigUInt(32323423423423), (BigUInt(32323423423423), BigUInt(8439439483934))
@@ -73,11 +77,11 @@ tests.artifacts.Contains.contract.MyContract.approval_program:
     callsub is_in_tuple_3
     // tests/artifacts/Contains/contract.py:28
     // BigUInt(32323423423423) + BigUInt(32323423423423),
-    byte 0x3acbc457977e
+    pushbytes 0x3acbc457977e
     // tests/artifacts/Contains/contract.py:29
     // (BigUInt(32323423423423), BigUInt(8439439483934)),
-    byte 0x1d65e22bcbbf
-    byte 0x07acf5cae41e
+    bytec_3 // 0x1d65e22bcbbf
+    bytec 4 // 0x07acf5cae41e
     // tests/artifacts/Contains/contract.py:27-30
     // three_false = self.is_in_tuple_3(
     //     BigUInt(32323423423423) + BigUInt(32323423423423),
@@ -92,15 +96,9 @@ tests.artifacts.Contains.contract.MyContract.approval_program:
     // assert not three_false, "Should be false"
     !
     assert // Should be false
-    // tests/artifacts/Contains/contract.py:34
-    // self.test_string_types()
-    callsub test_string_types
-    // tests/artifacts/Contains/contract.py:35
-    // self.test_numeric_types()
-    callsub test_numeric_types
     // tests/artifacts/Contains/contract.py:37
     // return UInt64(1)
-    int 1
+    intc_1 // 1
     return
 
 
@@ -122,13 +120,13 @@ is_in_tuple_1:
     bz is_in_tuple_1_bool_false@3
 
 is_in_tuple_1_bool_true@2:
-    int 1
-    b is_in_tuple_1_bool_merge@4
+    intc_1 // 1
+    // tests/artifacts/Contains/contract.py:44
+    // return x in y
+    retsub
 
 is_in_tuple_1_bool_false@3:
-    int 0
-
-is_in_tuple_1_bool_merge@4:
+    intc_0 // 0
     // tests/artifacts/Contains/contract.py:44
     // return x in y
     retsub
@@ -152,13 +150,13 @@ is_in_tuple_2:
     bz is_in_tuple_2_bool_false@3
 
 is_in_tuple_2_bool_true@2:
-    int 1
-    b is_in_tuple_2_bool_merge@4
+    intc_1 // 1
+    // tests/artifacts/Contains/contract.py:48
+    // return x in y
+    retsub
 
 is_in_tuple_2_bool_false@3:
-    int 0
-
-is_in_tuple_2_bool_merge@4:
+    intc_0 // 0
     // tests/artifacts/Contains/contract.py:48
     // return x in y
     retsub
@@ -182,1298 +180,13 @@ is_in_tuple_3:
     bz is_in_tuple_3_bool_false@3
 
 is_in_tuple_3_bool_true@2:
-    int 1
-    b is_in_tuple_3_bool_merge@4
-
-is_in_tuple_3_bool_false@3:
-    int 0
-
-is_in_tuple_3_bool_merge@4:
+    intc_1 // 1
     // tests/artifacts/Contains/contract.py:52
     // return x in y
     retsub
 
-
-// tests.artifacts.Contains.contract.MyContract.test_string_types() -> void:
-test_string_types:
-    // tests/artifacts/Contains/contract.py:54-55
-    // @subroutine
-    // def test_string_types(self) -> None:
-    proto 0 0
-    int 0
-    dupn 22
-    // tests/artifacts/Contains/contract.py:56
-    // assert foo_string() in (foo_string(), baz_string()), "foo in (foo, baz)"
-    callsub foo_string
-    dup
-    callsub foo_string
-    callsub baz_string
-    cover 2
-    ==
-    bnz test_string_types_bool_true@2
-    frame_dig 23
-    frame_dig 24
-    ==
-    bz test_string_types_bool_false@3
-
-test_string_types_bool_true@2:
-    int 1
-    b test_string_types_bool_merge@4
-
-test_string_types_bool_false@3:
-    int 0
-
-test_string_types_bool_merge@4:
-    // tests/artifacts/Contains/contract.py:56
-    // assert foo_string() in (foo_string(), baz_string()), "foo in (foo, baz)"
-    assert // foo in (foo, baz)
-    // tests/artifacts/Contains/contract.py:57
-    // assert foo_string() not in (bar_string(), baz_string()), "foo not in (bar, baz)"
-    callsub foo_string
-    dup
-    frame_bury 0
-    callsub bar_string
-    callsub baz_string
-    frame_bury 19
-    ==
-    bnz test_string_types_bool_true@6
-    frame_dig 0
-    frame_dig 19
-    ==
-    bz test_string_types_bool_false@7
-
-test_string_types_bool_true@6:
-    int 1
-    b test_string_types_bool_merge@8
-
-test_string_types_bool_false@7:
-    int 0
-
-test_string_types_bool_merge@8:
-    // tests/artifacts/Contains/contract.py:57
-    // assert foo_string() not in (bar_string(), baz_string()), "foo not in (bar, baz)"
-    !
-    assert // foo not in (bar, baz)
-    // tests/artifacts/Contains/contract.py:58
-    // assert foo_string() in (foo_arc4(), baz_string(), bar_string()), "foo in (foo, baz, bar)"
-    callsub foo_arc4
-    callsub baz_string
-    frame_bury 8
-    callsub bar_string
-    frame_bury 9
-    extract 2 0
-    callsub foo_string
-    dup
-    frame_bury 1
-    ==
-    bnz test_string_types_bool_true@11
-    frame_dig 1
-    frame_dig 8
-    ==
-    bnz test_string_types_bool_true@11
-    frame_dig 1
-    frame_dig 9
-    ==
-    bz test_string_types_bool_false@12
-
-test_string_types_bool_true@11:
-    int 1
-    b test_string_types_bool_merge@13
-
-test_string_types_bool_false@12:
-    int 0
-
-test_string_types_bool_merge@13:
-    // tests/artifacts/Contains/contract.py:58
-    // assert foo_string() in (foo_arc4(), baz_string(), bar_string()), "foo in (foo, baz, bar)"
-    assert // foo in (foo, baz, bar)
-    // tests/artifacts/Contains/contract.py:59
-    // assert foo_arc4() in (foo_string(), baz_string(), bar_string()), "foo in (foo, baz, bar)"
-    callsub foo_arc4
-    extract 2 0
-    dup
-    frame_bury 10
-    callsub foo_string
-    callsub baz_string
-    frame_bury 11
-    callsub bar_string
-    frame_bury 12
-    ==
-    bnz test_string_types_bool_true@16
-    frame_dig 10
-    frame_dig 11
-    ==
-    bnz test_string_types_bool_true@16
-    frame_dig 10
-    frame_dig 12
-    ==
-    bz test_string_types_bool_false@17
-
-test_string_types_bool_true@16:
-    int 1
-    b test_string_types_bool_merge@18
-
-test_string_types_bool_false@17:
-    int 0
-
-test_string_types_bool_merge@18:
-    // tests/artifacts/Contains/contract.py:59
-    // assert foo_arc4() in (foo_string(), baz_string(), bar_string()), "foo in (foo, baz, bar)"
-    assert // foo in (foo, baz, bar)
-    // tests/artifacts/Contains/contract.py:60
-    // assert foo_string() not in (bar_arc4(), baz_string()), "foo not in (bar, baz)"
-    callsub bar_arc4
-    callsub baz_string
-    frame_bury 13
-    extract 2 0
-    callsub foo_string
-    dup
-    frame_bury 2
-    ==
-    bnz test_string_types_bool_true@20
-    frame_dig 2
-    frame_dig 13
-    ==
-    bz test_string_types_bool_false@21
-
-test_string_types_bool_true@20:
-    int 1
-    b test_string_types_bool_merge@22
-
-test_string_types_bool_false@21:
-    int 0
-
-test_string_types_bool_merge@22:
-    // tests/artifacts/Contains/contract.py:60
-    // assert foo_string() not in (bar_arc4(), baz_string()), "foo not in (bar, baz)"
-    !
-    assert // foo not in (bar, baz)
-    // tests/artifacts/Contains/contract.py:61
-    // assert foo_arc4() not in (bar_arc4(), baz_string()), "foo not in (bar, baz)"
-    callsub foo_arc4
-    dup
-    frame_bury 3
-    callsub bar_arc4
-    callsub baz_string
-    frame_bury 14
-    ==
-    bnz test_string_types_bool_true@24
-    frame_dig 3
-    extract 2 0
-    frame_dig 14
-    ==
-    bz test_string_types_bool_false@25
-
-test_string_types_bool_true@24:
-    int 1
-    b test_string_types_bool_merge@26
-
-test_string_types_bool_false@25:
-    int 0
-
-test_string_types_bool_merge@26:
-    // tests/artifacts/Contains/contract.py:61
-    // assert foo_arc4() not in (bar_arc4(), baz_string()), "foo not in (bar, baz)"
-    !
-    assert // foo not in (bar, baz)
-    // tests/artifacts/Contains/contract.py:63
-    // bar_arc4(),
-    callsub bar_arc4
-    // tests/artifacts/Contains/contract.py:64
-    // baz_string(),
-    callsub baz_string
-    frame_bury 15
-    // tests/artifacts/Contains/contract.py:65
-    // foo_string(),
-    callsub foo_string
-    frame_bury 16
-    // tests/artifacts/Contains/contract.py:66
-    // one_u64(),
-    callsub one_u64
-    pop
-    // tests/artifacts/Contains/contract.py:62-67
-    // assert foo_string() in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     foo_string(),
-    //     one_u64(),
-    // ), "foo in (bar, baz, foo, 1)"
-    extract 2 0
-    // tests/artifacts/Contains/contract.py:62
-    // assert foo_string() in (
-    callsub foo_string
-    dup
-    frame_bury 4
-    // tests/artifacts/Contains/contract.py:62-67
-    // assert foo_string() in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     foo_string(),
-    //     one_u64(),
-    // ), "foo in (bar, baz, foo, 1)"
-    ==
-    bnz test_string_types_bool_true@29
-    frame_dig 4
-    frame_dig 15
-    ==
-    bnz test_string_types_bool_true@29
-    frame_dig 4
-    frame_dig 16
-    ==
-    bz test_string_types_bool_false@30
-
-test_string_types_bool_true@29:
-    int 1
-    b test_string_types_bool_merge@31
-
-test_string_types_bool_false@30:
-    int 0
-
-test_string_types_bool_merge@31:
-    // tests/artifacts/Contains/contract.py:62-67
-    // assert foo_string() in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     foo_string(),
-    //     one_u64(),
-    // ), "foo in (bar, baz, foo, 1)"
-    assert // foo in (bar, baz, foo, 1)
-    // tests/artifacts/Contains/contract.py:68
-    // assert foo_arc4() in (
-    callsub foo_arc4
-    dup
-    frame_bury 5
-    // tests/artifacts/Contains/contract.py:69
-    // bar_arc4(),
-    callsub bar_arc4
-    // tests/artifacts/Contains/contract.py:70
-    // baz_string(),
-    callsub baz_string
-    frame_bury 17
-    // tests/artifacts/Contains/contract.py:71
-    // foo_string(),
-    callsub foo_string
-    frame_bury 18
-    // tests/artifacts/Contains/contract.py:72
-    // one_u64(),
-    callsub one_u64
-    pop
-    // tests/artifacts/Contains/contract.py:68-73
-    // assert foo_arc4() in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     foo_string(),
-    //     one_u64(),
-    // ), "foo in (bar, baz, foo, 1)"
-    ==
-    bnz test_string_types_bool_true@34
-    // tests/artifacts/Contains/contract.py:68
-    // assert foo_arc4() in (
-    frame_dig 5
-    extract 2 0
-    dup
-    frame_bury 20
-    // tests/artifacts/Contains/contract.py:68-73
-    // assert foo_arc4() in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     foo_string(),
-    //     one_u64(),
-    // ), "foo in (bar, baz, foo, 1)"
-    frame_dig 17
-    ==
-    bnz test_string_types_bool_true@34
-    frame_dig 20
-    frame_dig 18
-    ==
-    bz test_string_types_bool_false@35
-
-test_string_types_bool_true@34:
-    int 1
-    b test_string_types_bool_merge@36
-
-test_string_types_bool_false@35:
-    int 0
-
-test_string_types_bool_merge@36:
-    // tests/artifacts/Contains/contract.py:68-73
-    // assert foo_arc4() in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     foo_string(),
-    //     one_u64(),
-    // ), "foo in (bar, baz, foo, 1)"
-    assert // foo in (bar, baz, foo, 1)
-    // tests/artifacts/Contains/contract.py:75
-    // bar_arc4(),
-    callsub bar_arc4
-    // tests/artifacts/Contains/contract.py:76
-    // baz_string(),
-    callsub baz_string
-    frame_bury 21
-    // tests/artifacts/Contains/contract.py:77
-    // one_u64(),
-    callsub one_u64
-    pop
-    // tests/artifacts/Contains/contract.py:74-78
-    // assert foo_string() not in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     one_u64(),
-    // ), "foo not in (bar, baz, 1)"
-    extract 2 0
-    // tests/artifacts/Contains/contract.py:74
-    // assert foo_string() not in (
-    callsub foo_string
-    dup
-    frame_bury 6
-    // tests/artifacts/Contains/contract.py:74-78
-    // assert foo_string() not in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     one_u64(),
-    // ), "foo not in (bar, baz, 1)"
-    ==
-    bnz test_string_types_bool_true@38
-    frame_dig 6
-    frame_dig 21
-    ==
-    bz test_string_types_bool_false@39
-
-test_string_types_bool_true@38:
-    int 1
-    b test_string_types_bool_merge@40
-
-test_string_types_bool_false@39:
-    int 0
-
-test_string_types_bool_merge@40:
-    // tests/artifacts/Contains/contract.py:74-78
-    // assert foo_string() not in (
-    //     bar_arc4(),
-    //     baz_string(),
-    //     one_u64(),
-    // ), "foo not in (bar, baz, 1)"
-    !
-    assert // foo not in (bar, baz, 1)
-    // tests/artifacts/Contains/contract.py:79
-    // assert foo_arc4() not in (bar_arc4(), baz_string(), one_u64()), "foo not in (bar, baz, 1)"
-    callsub foo_arc4
-    dup
-    frame_bury 7
-    callsub bar_arc4
-    callsub baz_string
-    frame_bury 22
-    callsub one_u64
-    pop
-    ==
-    bnz test_string_types_bool_true@42
-    frame_dig 7
-    extract 2 0
-    frame_dig 22
-    ==
-    bz test_string_types_bool_false@43
-
-test_string_types_bool_true@42:
-    int 1
-    b test_string_types_bool_merge@44
-
-test_string_types_bool_false@43:
-    int 0
-
-test_string_types_bool_merge@44:
-    // tests/artifacts/Contains/contract.py:79
-    // assert foo_arc4() not in (bar_arc4(), baz_string(), one_u64()), "foo not in (bar, baz, 1)"
-    !
-    assert // foo not in (bar, baz, 1)
-    // tests/artifacts/Contains/contract.py:81
-    // foo_string(),
-    callsub foo_string
-    pop
-    // tests/artifacts/Contains/contract.py:82
-    // foo_arc4(),
-    callsub foo_arc4
-    pop
-    retsub
-
-
-// tests.artifacts.Contains.contract.foo_string() -> bytes:
-foo_string:
-    // tests/artifacts/Contains/contract.py:167-168
-    // @subroutine
-    // def foo_string() -> String:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:169
-    // return String("foo")
-    byte "foo"
-    retsub
-
-
-// tests.artifacts.Contains.contract.baz_string() -> bytes:
-baz_string:
-    // tests/artifacts/Contains/contract.py:187-188
-    // @subroutine
-    // def baz_string() -> String:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:189
-    // return String("baz")
-    byte "baz"
-    retsub
-
-
-// tests.artifacts.Contains.contract.bar_string() -> bytes:
-bar_string:
-    // tests/artifacts/Contains/contract.py:177-178
-    // @subroutine
-    // def bar_string() -> String:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:179
-    // return String("bar")
-    byte "bar"
-    retsub
-
-
-// tests.artifacts.Contains.contract.foo_arc4() -> bytes:
-foo_arc4:
-    // tests/artifacts/Contains/contract.py:172-173
-    // @subroutine
-    // def foo_arc4() -> arc4.String:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:174
-    // return arc4.String("foo")
-    byte 0x0003666f6f
-    retsub
-
-
-// tests.artifacts.Contains.contract.bar_arc4() -> bytes:
-bar_arc4:
-    // tests/artifacts/Contains/contract.py:182-183
-    // @subroutine
-    // def bar_arc4() -> arc4.String:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:184
-    // return arc4.String("bar")
-    byte 0x0003626172
-    retsub
-
-
-// tests.artifacts.Contains.contract.one_u64() -> uint64:
-one_u64:
-    // tests/artifacts/Contains/contract.py:137-138
-    // @subroutine
-    // def one_u64() -> UInt64:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:139
-    // return UInt64(1)
-    int 1
-    retsub
-
-
-// tests.artifacts.Contains.contract.MyContract.test_numeric_types() -> void:
-test_numeric_types:
-    // tests/artifacts/Contains/contract.py:86-87
-    // @subroutine
-    // def test_numeric_types(self) -> None:
-    proto 0 0
-    int 0
-    dupn 26
-    byte ""
-    dupn 8
-    // tests/artifacts/Contains/contract.py:88
-    // assert one_u64() in (one_u64(), two_u64()), "1 in (1, 2)"
-    callsub one_u64
-    dup
-    callsub one_u64
-    callsub two_u64
-    cover 2
-    ==
-    bnz test_numeric_types_bool_true@2
-    frame_dig 36
-    frame_dig 37
-    ==
-    bz test_numeric_types_bool_false@3
-
-test_numeric_types_bool_true@2:
-    int 1
-    b test_numeric_types_bool_merge@4
-
-test_numeric_types_bool_false@3:
-    int 0
-
-test_numeric_types_bool_merge@4:
-    // tests/artifacts/Contains/contract.py:88
-    // assert one_u64() in (one_u64(), two_u64()), "1 in (1, 2)"
-    assert // 1 in (1, 2)
-    // tests/artifacts/Contains/contract.py:89
-    // assert one_u64() not in (UInt64(3), two_u64()), "1 not in (3, 2)"
-    callsub one_u64
-    dup
-    frame_bury 27
-    callsub two_u64
-    frame_bury 35
-    int 3
-    ==
-    bnz test_numeric_types_bool_true@6
-    frame_dig 27
-    frame_dig 35
-    ==
-    bz test_numeric_types_bool_false@7
-
-test_numeric_types_bool_true@6:
-    int 1
-    b test_numeric_types_bool_merge@8
-
-test_numeric_types_bool_false@7:
-    int 0
-
-test_numeric_types_bool_merge@8:
-    // tests/artifacts/Contains/contract.py:89
-    // assert one_u64() not in (UInt64(3), two_u64()), "1 not in (3, 2)"
-    !
-    assert // 1 not in (3, 2)
-    // tests/artifacts/Contains/contract.py:91
-    // assert one_u64() in (one_u64(), UInt64(3), two_u8()), "1 in (1, 3, 2)"
-    callsub one_u64
-    dup
-    frame_bury 30
-    callsub one_u64
-    callsub two_u8
-    frame_bury 23
-    ==
-    bnz test_numeric_types_bool_true@11
-    frame_dig 30
-    int 3
-    ==
-    bnz test_numeric_types_bool_true@11
-    frame_dig 30
-    itob
-    frame_dig 23
-    b==
-    bz test_numeric_types_bool_false@12
-
-test_numeric_types_bool_true@11:
-    int 1
-    b test_numeric_types_bool_merge@13
-
-test_numeric_types_bool_false@12:
-    int 0
-
-test_numeric_types_bool_merge@13:
-    // tests/artifacts/Contains/contract.py:91
-    // assert one_u64() in (one_u64(), UInt64(3), two_u8()), "1 in (1, 3, 2)"
-    assert // 1 in (1, 3, 2)
-    // tests/artifacts/Contains/contract.py:92
-    // assert one_u64() in (one_arc4u64(), UInt64(4), two_u8()), "1 in (1, 4, 2)"
-    callsub one_arc4u64
-    callsub two_u8
-    frame_bury 13
-    callsub one_u64
-    dup
-    frame_bury 32
-    itob
-    dup
-    frame_bury 14
-    b==
-    bnz test_numeric_types_bool_true@16
-    frame_dig 32
-    int 4
-    ==
-    bnz test_numeric_types_bool_true@16
-    frame_dig 13
-    frame_dig 14
-    b==
-    bz test_numeric_types_bool_false@17
-
-test_numeric_types_bool_true@16:
-    int 1
-    b test_numeric_types_bool_merge@18
-
-test_numeric_types_bool_false@17:
-    int 0
-
-test_numeric_types_bool_merge@18:
-    // tests/artifacts/Contains/contract.py:92
-    // assert one_u64() in (one_arc4u64(), UInt64(4), two_u8()), "1 in (1, 4, 2)"
-    assert // 1 in (1, 4, 2)
-    // tests/artifacts/Contains/contract.py:93
-    // assert UInt64(2) in (one_arc4u64(), UInt64(3), two_u8()), "2 in (1, 3, 2)"
-    callsub one_arc4u64
-    callsub two_u8
-    frame_bury 15
-    int 2
-    itob
-    dup
-    frame_bury 16
-    b==
-    bnz test_numeric_types_bool_true@21
-    frame_dig 15
-    frame_dig 16
-    b==
-    bz test_numeric_types_bool_false@22
-
-test_numeric_types_bool_true@21:
-    int 1
-    b test_numeric_types_bool_merge@23
-
-test_numeric_types_bool_false@22:
-    int 0
-
-test_numeric_types_bool_merge@23:
-    // tests/artifacts/Contains/contract.py:93
-    // assert UInt64(2) in (one_arc4u64(), UInt64(3), two_u8()), "2 in (1, 3, 2)"
-    assert // 2 in (1, 3, 2)
-    // tests/artifacts/Contains/contract.py:94
-    // assert two_u8() in (one_arc4u64(), UInt64(3), two_u8()), "2 in (1, 3, 2)"
-    callsub two_u8
-    dup
-    frame_bury 7
-    callsub one_arc4u64
-    callsub two_u8
-    frame_bury 17
-    b==
-    bnz test_numeric_types_bool_true@26
-    int 3
-    itob
-    frame_dig 7
-    b==
-    bnz test_numeric_types_bool_true@26
-    frame_dig 7
-    frame_dig 17
-    b==
-    bz test_numeric_types_bool_false@27
-
-test_numeric_types_bool_true@26:
-    int 1
-    b test_numeric_types_bool_merge@28
-
-test_numeric_types_bool_false@27:
-    int 0
-
-test_numeric_types_bool_merge@28:
-    // tests/artifacts/Contains/contract.py:94
-    // assert two_u8() in (one_arc4u64(), UInt64(3), two_u8()), "2 in (1, 3, 2)"
-    assert // 2 in (1, 3, 2)
-    // tests/artifacts/Contains/contract.py:95
-    // assert two_u8() in (one_arc4u64(), UInt64(2), UInt64(3)), "2 in (1, 2, 3)"
-    callsub two_u8
-    dup
-    frame_bury 8
-    callsub one_arc4u64
-    b==
-    bnz test_numeric_types_bool_true@31
-    frame_dig 8
-    frame_dig 16
-    b==
-    bnz test_numeric_types_bool_true@31
-    int 3
-    itob
-    frame_dig 8
-    b==
-    bz test_numeric_types_bool_false@32
-
-test_numeric_types_bool_true@31:
-    int 1
-    b test_numeric_types_bool_merge@33
-
-test_numeric_types_bool_false@32:
-    int 0
-
-test_numeric_types_bool_merge@33:
-    // tests/artifacts/Contains/contract.py:95
-    // assert two_u8() in (one_arc4u64(), UInt64(2), UInt64(3)), "2 in (1, 2, 3)"
-    assert // 2 in (1, 2, 3)
-    // tests/artifacts/Contains/contract.py:96
-    // assert three_u512() in (UInt64(3), UInt64(4)), "3 in (3, 4)"
-    callsub three_u512
-    dup
-    frame_bury 9
-    int 3
-    itob
-    dup
-    frame_bury 18
-    b==
-    bnz test_numeric_types_bool_true@35
-    int 4
-    itob
-    frame_dig 9
-    b==
-    bz test_numeric_types_bool_false@36
-
-test_numeric_types_bool_true@35:
-    int 1
-    b test_numeric_types_bool_merge@37
-
-test_numeric_types_bool_false@36:
-    int 0
-
-test_numeric_types_bool_merge@37:
-    // tests/artifacts/Contains/contract.py:96
-    // assert three_u512() in (UInt64(3), UInt64(4)), "3 in (3, 4)"
-    assert // 3 in (3, 4)
-    // tests/artifacts/Contains/contract.py:97
-    // assert four_biguint() in (UInt64(5), UInt64(4)), "4 in (5, 4)"
-    callsub four_biguint
-    dup
-    frame_bury 10
-    int 5
-    itob
-    dup
-    frame_bury 19
-    b==
-    bnz test_numeric_types_bool_true@39
-    int 4
-    itob
-    frame_dig 10
-    b==
-    bz test_numeric_types_bool_false@40
-
-test_numeric_types_bool_true@39:
-    int 1
-    b test_numeric_types_bool_merge@41
-
-test_numeric_types_bool_false@40:
-    int 0
-
-test_numeric_types_bool_merge@41:
-    // tests/artifacts/Contains/contract.py:97
-    // assert four_biguint() in (UInt64(5), UInt64(4)), "4 in (5, 4)"
-    assert // 4 in (5, 4)
-    // tests/artifacts/Contains/contract.py:99
-    // assert one_u64() not in (UInt64(5), two_u8()), "1 not in (5, 2)"
-    callsub one_u64
-    dup
-    frame_bury 33
-    callsub two_u8
-    frame_bury 20
-    int 5
-    ==
-    bnz test_numeric_types_bool_true@43
-    frame_dig 33
-    itob
-    frame_dig 20
-    b==
-    bz test_numeric_types_bool_false@44
-
-test_numeric_types_bool_true@43:
-    int 1
-    b test_numeric_types_bool_merge@45
-
-test_numeric_types_bool_false@44:
-    int 0
-
-test_numeric_types_bool_merge@45:
-    // tests/artifacts/Contains/contract.py:99
-    // assert one_u64() not in (UInt64(5), two_u8()), "1 not in (5, 2)"
-    !
-    assert // 1 not in (5, 2)
-    // tests/artifacts/Contains/contract.py:100
-    // assert one_u64() not in (Application(1), UInt64(3), two_u8()), "1 not in (app(1), 3, 2)"
-    callsub one_u64
-    dup
-    frame_bury 34
-    callsub two_u8
-    frame_bury 21
-    int 3
-    ==
-    bnz test_numeric_types_bool_true@47
-    frame_dig 34
-    itob
-    frame_dig 21
-    b==
-    bz test_numeric_types_bool_false@48
-
-test_numeric_types_bool_true@47:
-    int 1
-    b test_numeric_types_bool_merge@49
-
-test_numeric_types_bool_false@48:
-    int 0
-
-test_numeric_types_bool_merge@49:
-    // tests/artifacts/Contains/contract.py:100
-    // assert one_u64() not in (Application(1), UInt64(3), two_u8()), "1 not in (app(1), 3, 2)"
-    !
-    assert // 1 not in (app(1), 3, 2)
-    // tests/artifacts/Contains/contract.py:101
-    // assert one_u64() not in (UInt64(3), two_u8()), "1 not in (3, 2)"
-    callsub one_u64
-    dup
-    frame_bury 28
-    callsub two_u8
-    frame_bury 22
-    int 3
-    ==
-    bnz test_numeric_types_bool_true@51
-    frame_dig 28
-    itob
-    frame_dig 22
-    b==
-    bz test_numeric_types_bool_false@52
-
-test_numeric_types_bool_true@51:
-    int 1
-    b test_numeric_types_bool_merge@53
-
-test_numeric_types_bool_false@52:
-    int 0
-
-test_numeric_types_bool_merge@53:
-    // tests/artifacts/Contains/contract.py:101
-    // assert one_u64() not in (UInt64(3), two_u8()), "1 not in (3, 2)"
-    !
-    assert // 1 not in (3, 2)
-    // tests/artifacts/Contains/contract.py:102
-    // assert UInt64(2) not in (one_arc4u64(), UInt64(3)), "2 not in (1, 3)"
-    callsub one_arc4u64
-    frame_dig 16
-    b==
-    bnz test_numeric_types_bool_true@55
-    int 0
-    b test_numeric_types_bool_merge@57
-
-test_numeric_types_bool_true@55:
-    int 1
-
-test_numeric_types_bool_merge@57:
-    // tests/artifacts/Contains/contract.py:102
-    // assert UInt64(2) not in (one_arc4u64(), UInt64(3)), "2 not in (1, 3)"
-    !
-    assert // 2 not in (1, 3)
-    // tests/artifacts/Contains/contract.py:103
-    // assert two_u8() not in (one_arc4u64(), UInt64(3)), "2 not in (1, 3)"
-    callsub two_u8
-    dup
-    frame_bury 0
-    callsub one_arc4u64
-    b==
-    bnz test_numeric_types_bool_true@59
-    frame_dig 0
-    frame_dig 18
-    b==
-    bz test_numeric_types_bool_false@60
-
-test_numeric_types_bool_true@59:
-    int 1
-    b test_numeric_types_bool_merge@61
-
-test_numeric_types_bool_false@60:
-    int 0
-
-test_numeric_types_bool_merge@61:
-    // tests/artifacts/Contains/contract.py:103
-    // assert two_u8() not in (one_arc4u64(), UInt64(3)), "2 not in (1, 3)"
-    !
-    assert // 2 not in (1, 3)
-    // tests/artifacts/Contains/contract.py:104
-    // assert two_u8() not in (one_arc4u64(), UInt64(3)), "2 not in (1, 3)"
-    callsub two_u8
-    dup
-    frame_bury 1
-    callsub one_arc4u64
-    b==
-    bnz test_numeric_types_bool_true@63
-    frame_dig 1
-    frame_dig 18
-    b==
-    bz test_numeric_types_bool_false@64
-
-test_numeric_types_bool_true@63:
-    int 1
-    b test_numeric_types_bool_merge@65
-
-test_numeric_types_bool_false@64:
-    int 0
-
-test_numeric_types_bool_merge@65:
-    // tests/artifacts/Contains/contract.py:104
-    // assert two_u8() not in (one_arc4u64(), UInt64(3)), "2 not in (1, 3)"
-    !
-    assert // 2 not in (1, 3)
-    // tests/artifacts/Contains/contract.py:105
-    // assert three_u512() not in (UInt64(5), UInt64(7)), "3 not in (5, 7)"
-    callsub three_u512
-    dup
-    frame_bury 2
-    frame_dig 19
-    b==
-    bnz test_numeric_types_bool_true@67
-    int 7
-    itob
-    frame_dig 2
-    b==
-    bz test_numeric_types_bool_false@68
-
-test_numeric_types_bool_true@67:
-    int 1
-    b test_numeric_types_bool_merge@69
-
-test_numeric_types_bool_false@68:
-    int 0
-
-test_numeric_types_bool_merge@69:
-    // tests/artifacts/Contains/contract.py:105
-    // assert three_u512() not in (UInt64(5), UInt64(7)), "3 not in (5, 7)"
-    !
-    assert // 3 not in (5, 7)
-    // tests/artifacts/Contains/contract.py:106
-    // assert four_biguint() not in (UInt64(2), UInt64(9)), "4 not in (2, 9)"
-    callsub four_biguint
-    dup
-    frame_bury 3
-    frame_dig 16
-    b==
-    bnz test_numeric_types_bool_true@71
-    int 9
-    itob
-    frame_dig 3
-    b==
-    bz test_numeric_types_bool_false@72
-
-test_numeric_types_bool_true@71:
-    int 1
-    b test_numeric_types_bool_merge@73
-
-test_numeric_types_bool_false@72:
-    int 0
-
-test_numeric_types_bool_merge@73:
-    // tests/artifacts/Contains/contract.py:106
-    // assert four_biguint() not in (UInt64(2), UInt64(9)), "4 not in (2, 9)"
-    !
-    assert // 4 not in (2, 9)
-    // tests/artifacts/Contains/contract.py:108
-    // assert one_u64() in (
-    callsub one_u64
-    dup
-    frame_bury 29
-    // tests/artifacts/Contains/contract.py:109
-    // foo_string(),
-    callsub foo_string
-    pop
-    // tests/artifacts/Contains/contract.py:110
-    // one_u64(),
-    callsub one_u64
-    // tests/artifacts/Contains/contract.py:112
-    // two_u8(),
-    callsub two_u8
-    frame_bury 24
-    // tests/artifacts/Contains/contract.py:108-113
-    // assert one_u64() in (
-    //     foo_string(),
-    //     one_u64(),
-    //     UInt64(3),
-    //     two_u8(),
-    // ), "1 in (foo, 1, 3, 2)"
-    ==
-    bnz test_numeric_types_bool_true@76
-    frame_dig 29
-    // tests/artifacts/Contains/contract.py:111
-    // UInt64(3),
-    int 3
-    // tests/artifacts/Contains/contract.py:108-113
-    // assert one_u64() in (
-    //     foo_string(),
-    //     one_u64(),
-    //     UInt64(3),
-    //     two_u8(),
-    // ), "1 in (foo, 1, 3, 2)"
-    ==
-    bnz test_numeric_types_bool_true@76
-    frame_dig 29
-    itob
-    frame_dig 24
-    b==
-    bz test_numeric_types_bool_false@77
-
-test_numeric_types_bool_true@76:
-    int 1
-    b test_numeric_types_bool_merge@78
-
-test_numeric_types_bool_false@77:
-    int 0
-
-test_numeric_types_bool_merge@78:
-    // tests/artifacts/Contains/contract.py:108-113
-    // assert one_u64() in (
-    //     foo_string(),
-    //     one_u64(),
-    //     UInt64(3),
-    //     two_u8(),
-    // ), "1 in (foo, 1, 3, 2)"
-    assert // 1 in (foo, 1, 3, 2)
-    // tests/artifacts/Contains/contract.py:114
-    // assert one_u64() in (one_arc4u64(), bar_string(), two_u8()), "1 in (1, bar, 2)"
-    callsub one_arc4u64
-    callsub bar_string
-    pop
-    callsub two_u8
-    frame_bury 25
-    callsub one_u64
-    itob
-    dup
-    frame_bury 26
-    b==
-    bnz test_numeric_types_bool_true@80
-    frame_dig 25
-    frame_dig 26
-    b==
-    bz test_numeric_types_bool_false@81
-
-test_numeric_types_bool_true@80:
-    int 1
-    b test_numeric_types_bool_merge@82
-
-test_numeric_types_bool_false@81:
-    int 0
-
-test_numeric_types_bool_merge@82:
-    // tests/artifacts/Contains/contract.py:114
-    // assert one_u64() in (one_arc4u64(), bar_string(), two_u8()), "1 in (1, bar, 2)"
-    assert // 1 in (1, bar, 2)
-    // tests/artifacts/Contains/contract.py:115
-    // assert UInt64(2) in (foo_arc4(), UInt64(3), two_u8()), "2 in (foo, 3, 2)"
-    callsub foo_arc4
-    pop
-    callsub two_u8
-    frame_dig 16
-    b==
-    bz test_numeric_types_bool_false@85
-    int 1
-    b test_numeric_types_bool_merge@86
-
-test_numeric_types_bool_false@85:
-    int 0
-
-test_numeric_types_bool_merge@86:
-    // tests/artifacts/Contains/contract.py:115
-    // assert UInt64(2) in (foo_arc4(), UInt64(3), two_u8()), "2 in (foo, 3, 2)"
-    assert // 2 in (foo, 3, 2)
-    // tests/artifacts/Contains/contract.py:116
-    // assert two_u8() in (bar_arc4(), UInt64(3), two_u8()), "2 in (bar, 3, 2)"
-    callsub two_u8
-    dup
-    frame_bury 4
-    callsub bar_arc4
-    pop
-    callsub two_u8
-    frame_bury 11
-    frame_dig 18
-    b==
-    bnz test_numeric_types_bool_true@88
-    frame_dig 4
-    frame_dig 11
-    b==
-    bz test_numeric_types_bool_false@89
-
-test_numeric_types_bool_true@88:
-    int 1
-    b test_numeric_types_bool_merge@90
-
-test_numeric_types_bool_false@89:
-    int 0
-
-test_numeric_types_bool_merge@90:
-    // tests/artifacts/Contains/contract.py:116
-    // assert two_u8() in (bar_arc4(), UInt64(3), two_u8()), "2 in (bar, 3, 2)"
-    assert // 2 in (bar, 3, 2)
-    // tests/artifacts/Contains/contract.py:117
-    // assert two_u8() in (foo_string(), UInt64(2), UInt64(3)), "2 in foo(2, 3)"
-    callsub two_u8
-    dup
-    frame_bury 5
-    callsub foo_string
-    pop
-    frame_dig 16
-    b==
-    bnz test_numeric_types_bool_true@92
-    frame_dig 5
-    frame_dig 18
-    b==
-    bz test_numeric_types_bool_false@93
-
-test_numeric_types_bool_true@92:
-    int 1
-    b test_numeric_types_bool_merge@94
-
-test_numeric_types_bool_false@93:
-    int 0
-
-test_numeric_types_bool_merge@94:
-    // tests/artifacts/Contains/contract.py:117
-    // assert two_u8() in (foo_string(), UInt64(2), UInt64(3)), "2 in foo(2, 3)"
-    assert // 2 in foo(2, 3)
-    // tests/artifacts/Contains/contract.py:118
-    // assert three_u512() in (UInt64(5), UInt64(3), foo_string()), "3 in (5, 3, foo)"
-    callsub three_u512
-    dup
-    frame_bury 6
-    callsub foo_string
-    pop
-    frame_dig 19
-    b==
-    bnz test_numeric_types_bool_true@96
-    frame_dig 6
-    frame_dig 18
-    b==
-    bz test_numeric_types_bool_false@97
-
-test_numeric_types_bool_true@96:
-    int 1
-    b test_numeric_types_bool_merge@98
-
-test_numeric_types_bool_false@97:
-    int 0
-
-test_numeric_types_bool_merge@98:
-    // tests/artifacts/Contains/contract.py:118
-    // assert three_u512() in (UInt64(5), UInt64(3), foo_string()), "3 in (5, 3, foo)"
-    assert // 3 in (5, 3, foo)
-    // tests/artifacts/Contains/contract.py:120
-    // assert one_u64() not in (
-    callsub one_u64
-    dup
-    frame_bury 31
-    // tests/artifacts/Contains/contract.py:121
-    // foo_string(),
-    callsub foo_string
-    pop
-    // tests/artifacts/Contains/contract.py:123
-    // two_u8(),
-    callsub two_u8
-    frame_bury 12
-    // tests/artifacts/Contains/contract.py:122
-    // UInt64(3),
-    int 3
-    // tests/artifacts/Contains/contract.py:120-124
-    // assert one_u64() not in (
-    //     foo_string(),
-    //     UInt64(3),
-    //     two_u8(),
-    // ), "1 not in (foo, 3, 2)"
-    ==
-    bnz test_numeric_types_bool_true@100
-    frame_dig 31
-    itob
-    frame_dig 12
-    b==
-    bz test_numeric_types_bool_false@101
-
-test_numeric_types_bool_true@100:
-    int 1
-    b test_numeric_types_bool_merge@102
-
-test_numeric_types_bool_false@101:
-    int 0
-
-test_numeric_types_bool_merge@102:
-    // tests/artifacts/Contains/contract.py:120-124
-    // assert one_u64() not in (
-    //     foo_string(),
-    //     UInt64(3),
-    //     two_u8(),
-    // ), "1 not in (foo, 3, 2)"
-    !
-    assert // 1 not in (foo, 3, 2)
-    // tests/artifacts/Contains/contract.py:125
-    // assert one_u64() not in (bar_string(), two_u8()), "1 not in (bar, 2)"
-    callsub bar_string
-    pop
-    callsub two_u8
-    callsub one_u64
-    itob
-    b==
-    !
-    assert // 1 not in (bar, 2)
-    // tests/artifacts/Contains/contract.py:126
-    // assert UInt64(2) not in (foo_arc4(), UInt64(3)), "2 not in (foo, 3)"
-    callsub foo_arc4
-    pop
-    // tests/artifacts/Contains/contract.py:127
-    // assert two_u8() not in (bar_arc4(), UInt64(3)), "2 not in (bar, 3)"
-    callsub two_u8
-    callsub bar_arc4
-    pop
-    frame_dig 18
-    dup
-    cover 2
-    b==
-    !
-    assert // 2 not in (bar, 3)
-    // tests/artifacts/Contains/contract.py:128
-    // assert two_u8() not in (foo_string(), UInt64(3)), "2 not in (foo, 3)"
-    callsub two_u8
-    callsub foo_string
-    pop
-    b==
-    !
-    assert // 2 not in (foo, 3)
-    // tests/artifacts/Contains/contract.py:129
-    // assert three_u512() not in (UInt64(5), foo_string()), "3 not in (5, foo)"
-    callsub three_u512
-    callsub foo_string
-    pop
-    frame_dig 19
-    b==
-    !
-    assert // 3 not in (5, foo)
-    retsub
-
-
-// tests.artifacts.Contains.contract.two_u64() -> uint64:
-two_u64:
-    // tests/artifacts/Contains/contract.py:147-148
-    // @subroutine
-    // def two_u64() -> UInt64:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:149
-    // return UInt64(2)
-    int 2
-    retsub
-
-
-// tests.artifacts.Contains.contract.two_u8() -> bytes:
-two_u8:
-    // tests/artifacts/Contains/contract.py:152-153
-    // @subroutine
-    // def two_u8() -> arc4.UInt8:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:154
-    // return arc4.UInt8(2)
-    byte 0x02
-    retsub
-
-
-// tests.artifacts.Contains.contract.one_arc4u64() -> bytes:
-one_arc4u64:
-    // tests/artifacts/Contains/contract.py:142-143
-    // @subroutine
-    // def one_arc4u64() -> arc4.UInt64:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:144
-    // return arc4.UInt64(1)
-    byte 0x0000000000000001
-    retsub
-
-
-// tests.artifacts.Contains.contract.three_u512() -> bytes:
-three_u512:
-    // tests/artifacts/Contains/contract.py:157-158
-    // @subroutine
-    // def three_u512() -> arc4.UInt512:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:159
-    // return arc4.UInt512(3)
-    byte 0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003
-    retsub
-
-
-// tests.artifacts.Contains.contract.four_biguint() -> bytes:
-four_biguint:
-    // tests/artifacts/Contains/contract.py:162-163
-    // @subroutine
-    // def four_biguint() -> BigUInt:
-    proto 0 1
-    // tests/artifacts/Contains/contract.py:164
-    // return BigUInt(4)
-    byte 0x04
+is_in_tuple_3_bool_false@3:
+    intc_0 // 0
+    // tests/artifacts/Contains/contract.py:52
+    // return x in y
     retsub
diff --git a/tests/artifacts/Contains/data/MyContract.clear.teal b/tests/artifacts/Contains/data/MyContract.clear.teal
index c1315b5..e169910 100644
--- a/tests/artifacts/Contains/data/MyContract.clear.teal
+++ b/tests/artifacts/Contains/data/MyContract.clear.teal
@@ -1,7 +1,9 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.Contains.contract.MyContract.clear_state_program:
+// tests.artifacts.Contains.contract.MyContract.clear_state_program() -> uint64:
+main:
     // tests/artifacts/Contains/contract.py:40
     // return UInt64(1)
-    int 1
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.approval.teal b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.approval.teal
index c75b91e..d540450 100644
--- a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.approval.teal
+++ b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.approval.teal
@@ -1,40 +1,72 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.CreatedAppAsset.contract.AppExpectingEffects.approval_program:
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1 0 6
+    bytecblock 0x151f7c75
     // tests/artifacts/CreatedAppAsset/contract.py:4
     // class AppExpectingEffects(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@6
-    method "create_group(acfg,appl)(uint64,uint64)"
-    method "log_group(appl)void"
+    bz main_bare_routing@7
+    pushbytess 0x6d3a0439 0x62a0ef62 // method "create_group(acfg,appl)(uint64,uint64)", method "log_group(appl)void"
     txna ApplicationArgs 0
-    match main_create_group_route@2 main_log_group_route@3
-    err // reject transaction
+    match main_create_group_route@3 main_log_group_route@4
 
-main_create_group_route@2:
+main_after_if_else@11:
+    // tests/artifacts/CreatedAppAsset/contract.py:4
+    // class AppExpectingEffects(ARC4Contract):
+    intc_1 // 0
+    return
+
+main_log_group_route@4:
+    // tests/artifacts/CreatedAppAsset/contract.py:22
+    // @arc4.abimethod
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    // tests/artifacts/CreatedAppAsset/contract.py:4
+    // class AppExpectingEffects(ARC4Contract):
+    txn GroupIndex
+    intc_0 // 1
+    -
+    dup
+    gtxns TypeEnum
+    intc_2 // appl
+    ==
+    assert // transaction type is appl
+    // tests/artifacts/CreatedAppAsset/contract.py:22
+    // @arc4.abimethod
+    callsub log_group
+    intc_0 // 1
+    return
+
+main_create_group_route@3:
     // tests/artifacts/CreatedAppAsset/contract.py:5
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/CreatedAppAsset/contract.py:4
     // class AppExpectingEffects(ARC4Contract):
     txn GroupIndex
-    int 2
+    pushint 2 // 2
     -
     dup
     gtxns TypeEnum
-    int acfg
+    pushint 3 // acfg
     ==
     assert // transaction type is acfg
     txn GroupIndex
-    int 1
+    intc_0 // 1
     -
     dup
     gtxns TypeEnum
-    int appl
+    intc_2 // appl
     ==
     assert // transaction type is appl
     // tests/artifacts/CreatedAppAsset/contract.py:5
@@ -45,47 +77,22 @@ main_create_group_route@2:
     swap
     itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
-    return
-
-main_log_group_route@3:
-    // tests/artifacts/CreatedAppAsset/contract.py:22
-    // @arc4.abimethod
-    txn OnCompletion
-    !
-    assert // OnCompletion is NoOp
-    txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/CreatedAppAsset/contract.py:4
-    // class AppExpectingEffects(ARC4Contract):
-    txn GroupIndex
-    int 1
-    -
-    dup
-    gtxns TypeEnum
-    int appl
-    ==
-    assert // transaction type is appl
-    // tests/artifacts/CreatedAppAsset/contract.py:22
-    // @arc4.abimethod
-    callsub log_group
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@6:
+main_bare_routing@7:
     // tests/artifacts/CreatedAppAsset/contract.py:4
     // class AppExpectingEffects(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@11
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
@@ -149,20 +156,20 @@ log_group:
     // tests/artifacts/CreatedAppAsset/contract.py:24
     // assert app_call.app_args(0) == arc4.arc4_signature(
     frame_dig -1
-    int 0
+    intc_1 // 0
     gtxnsas ApplicationArgs
     // tests/artifacts/CreatedAppAsset/contract.py:24-26
     // assert app_call.app_args(0) == arc4.arc4_signature(
     //     "some_value()uint64"
     // ), "expected correct method called"
-    method "some_value()uint64"
+    pushbytes 0xd3479e65 // method "some_value()uint64"
     ==
     assert // expected correct method called
     // tests/artifacts/CreatedAppAsset/contract.py:27
     // assert app_call.num_logs == 1, "expected logs"
     frame_dig -1
     gtxns NumLogs
-    int 1
+    intc_0 // 1
     ==
     assert // expected logs
     // tests/artifacts/CreatedAppAsset/contract.py:29
@@ -173,14 +180,14 @@ log_group:
     extract 4 0
     swap
     extract 0 4
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     ==
     assert // ARC4 prefix is valid
     // tests/artifacts/CreatedAppAsset/contract.py:30
     // == (app_call.group_index + 1) * Global.group_size
     frame_dig -1
     gtxns GroupIndex
-    int 1
+    intc_0 // 1
     +
     global GroupSize
     *
diff --git a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc32.json b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc32.json
index c04dfad..90474d5 100644
--- a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc32.json
+++ b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.arc32.json
@@ -12,8 +12,8 @@
         }
     },
     "source": {
-        "approval": "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",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuQ3JlYXRlZEFwcEFzc2V0LmNvbnRyYWN0LkFwcEV4cGVjdGluZ0VmZmVjdHMuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvY29udHJhY3QucHk6NAogICAgLy8gY2xhc3MgQXBwRXhwZWN0aW5nRWZmZWN0cyhBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.clear.teal b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.clear.teal
index d1bb634..a433105 100644
--- a/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.clear.teal
+++ b/tests/artifacts/CreatedAppAsset/data/AppExpectingEffects.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.CreatedAppAsset.contract.AppExpectingEffects.clear_state_program:
-    // tests/artifacts/CreatedAppAsset/contract.py:4
-    // class AppExpectingEffects(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal b/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal
index 748efa2..3714d61 100644
--- a/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal
+++ b/tests/artifacts/CryptoOps/data/CryptoOpsContract.approval.teal
@@ -1,181 +1,273 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.CryptoOps.contract.CryptoOpsContract.approval_program:
+// 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@17
-    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)"
+    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@2 main_verify_sha3_256_route@3 main_verify_keccak_256_route@4 main_verify_sha512_256_route@5 main_verify_ed25519verify_route@6 main_verify_ed25519verify_bare_route@7 main_verify_ecdsa_verify_k1_route@8 main_verify_ecdsa_verify_r1_route@9 main_verify_ecdsa_recover_k1_route@10 main_verify_ecdsa_recover_r1_route@11 main_verify_ecdsa_decompress_k1_route@12 main_verify_ecdsa_decompress_r1_route@13 main_verify_vrf_verify_route@14
-    err // reject transaction
+    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_verify_sha256_route@2:
-    // tests/artifacts/CryptoOps/contract.py:5
+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 NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    txna ApplicationArgs 3
+    extract 2 0
+    // tests/artifacts/CryptoOps/contract.py:80
     // @arc4.abimethod()
-    callsub verify_sha256
-    dup
+    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
-    byte 0x151f7c75
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_sha3_256_route@3:
-    // tests/artifacts/CryptoOps/contract.py:11
+main_verify_ecdsa_decompress_r1_route@14:
+    // tests/artifacts/CryptoOps/contract.py:75
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/CryptoOps/contract.py:75
     // @arc4.abimethod()
-    callsub verify_sha3_256
-    dup
+    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
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_keccak_256_route@4:
-    // tests/artifacts/CryptoOps/contract.py:17
+main_verify_ecdsa_decompress_k1_route@13:
+    // tests/artifacts/CryptoOps/contract.py:70
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/CryptoOps/contract.py:70
     // @arc4.abimethod()
-    callsub verify_keccak_256
-    dup
+    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
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_sha512_256_route@5:
-    // tests/artifacts/CryptoOps/contract.py:23
+main_verify_ecdsa_recover_r1_route@12:
+    // tests/artifacts/CryptoOps/contract.py:60
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 3
+    extract 2 0
+    txna ApplicationArgs 4
+    extract 2 0
+    // tests/artifacts/CryptoOps/contract.py:60
     // @arc4.abimethod()
-    callsub verify_sha512_256
-    dup
+    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
-    byte 0x151f7c75
+    uncover 2
+    concat
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ed25519verify_route@6:
-    // tests/artifacts/CryptoOps/contract.py:29
+main_verify_ecdsa_recover_k1_route@11:
+    // tests/artifacts/CryptoOps/contract.py:53
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    btoi
     txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/CryptoOps/contract.py:29
+    txna ApplicationArgs 4
+    extract 2 0
+    // tests/artifacts/CryptoOps/contract.py:53
     // @arc4.abimethod()
-    callsub verify_ed25519verify
-    byte 0x151f7c75
+    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
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ed25519verify_bare_route@7:
-    // tests/artifacts/CryptoOps/contract.py:35
+main_verify_ecdsa_verify_r1_route@10:
+    // tests/artifacts/CryptoOps/contract.py:47
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/CryptoOps/contract.py:4
     // class CryptoOpsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -184,24 +276,32 @@ main_verify_ed25519verify_bare_route@7:
     extract 2 0
     txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/CryptoOps/contract.py:35
+    txna ApplicationArgs 4
+    extract 2 0
+    txna ApplicationArgs 5
+    extract 2 0
+    // tests/artifacts/CryptoOps/contract.py:47
     // @arc4.abimethod()
-    callsub verify_ed25519verify_bare
-    byte 0x151f7c75
+    callsub verify_ecdsa_verify_r1
+    bytec_1 // 0x00
+    intc_0 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ecdsa_verify_k1_route@8:
+main_verify_ecdsa_verify_k1_route@9:
     // tests/artifacts/CryptoOps/contract.py:41
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/CryptoOps/contract.py:4
     // class CryptoOpsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -217,25 +317,25 @@ main_verify_ecdsa_verify_k1_route@8:
     // tests/artifacts/CryptoOps/contract.py:41
     // @arc4.abimethod()
     callsub verify_ecdsa_verify_k1
-    byte 0x00
-    int 0
+    bytec_1 // 0x00
+    intc_0 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ecdsa_verify_r1_route@9:
-    // tests/artifacts/CryptoOps/contract.py:47
+main_verify_ed25519verify_bare_route@8:
+    // tests/artifacts/CryptoOps/contract.py:35
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/CryptoOps/contract.py:4
     // class CryptoOpsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -244,287 +344,216 @@ main_verify_ecdsa_verify_r1_route@9:
     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
+    // tests/artifacts/CryptoOps/contract.py:35
     // @arc4.abimethod()
-    callsub verify_ecdsa_verify_r1
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_ed25519verify_bare
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ecdsa_recover_k1_route@10:
-    // tests/artifacts/CryptoOps/contract.py:53
+main_verify_ed25519verify_route@7:
+    // tests/artifacts/CryptoOps/contract.py:29
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/CryptoOps/contract.py:53
+    // tests/artifacts/CryptoOps/contract.py:29
     // @arc4.abimethod()
-    callsub verify_ecdsa_recover_k1
-    swap
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    dig 1
-    len
-    itob
-    extract 6 2
-    uncover 2
-    concat
-    swap
-    dup
-    len
-    int 4
-    +
-    itob
-    extract 6 2
-    byte 0x0004
-    swap
-    concat
-    swap
-    concat
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_ed25519verify
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ecdsa_recover_r1_route@11:
-    // tests/artifacts/CryptoOps/contract.py:60
+main_verify_sha512_256_route@6:
+    // tests/artifacts/CryptoOps/contract.py:23
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/CryptoOps/contract.py:23
     // @arc4.abimethod()
-    callsub verify_ecdsa_recover_r1
-    swap
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    dig 1
-    len
-    itob
-    extract 6 2
-    uncover 2
-    concat
-    swap
+    callsub verify_sha512_256
     dup
     len
-    int 4
-    +
     itob
     extract 6 2
-    byte 0x0004
     swap
     concat
-    swap
-    concat
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ecdsa_decompress_k1_route@12:
-    // tests/artifacts/CryptoOps/contract.py:70
+main_verify_keccak_256_route@5:
+    // tests/artifacts/CryptoOps/contract.py:17
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/CryptoOps/contract.py:17
     // @arc4.abimethod()
-    callsub verify_ecdsa_decompress_k1
-    swap
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    dig 1
-    len
-    itob
-    extract 6 2
-    uncover 2
-    concat
-    swap
+    callsub verify_keccak_256
     dup
     len
-    int 4
-    +
     itob
     extract 6 2
-    byte 0x0004
-    swap
-    concat
-    swap
-    concat
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_ecdsa_decompress_r1_route@13:
-    // tests/artifacts/CryptoOps/contract.py:75
+main_verify_sha3_256_route@4:
+    // tests/artifacts/CryptoOps/contract.py:11
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/CryptoOps/contract.py:11
     // @arc4.abimethod()
-    callsub verify_ecdsa_decompress_r1
-    swap
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    dig 1
-    len
-    itob
-    extract 6 2
-    uncover 2
-    concat
-    swap
+    callsub verify_sha3_256
     dup
     len
-    int 4
-    +
     itob
     extract 6 2
-    byte 0x0004
     swap
     concat
-    swap
-    concat
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_verify_vrf_verify_route@14:
-    // tests/artifacts/CryptoOps/contract.py:80
+main_verify_sha256_route@3:
+    // tests/artifacts/CryptoOps/contract.py:5
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    btoi
+    // tests/artifacts/CryptoOps/contract.py:5
     // @arc4.abimethod()
-    callsub verify_vrf_verify
-    swap
+    callsub verify_sha256
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x00
-    int 0
-    uncover 3
-    setbit
-    byte 0x0003
-    swap
-    concat
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_1 // 1
     return
 
-main_bare_routing@17:
+main_bare_routing@18:
     // tests/artifacts/CryptoOps/contract.py:4
     // class CryptoOpsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@22
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    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
@@ -621,8 +650,8 @@ verify_ed25519verify:
     proto 3 1
     // tests/artifacts/CryptoOps/contract.py:31
     // ensure_budget(1900, OpUpFeeSource.GroupCredit)
-    int 1900
-    int 0
+    pushint 1900 // 1900
+    intc_0 // 0
     callsub ensure_budget
     // tests/artifacts/CryptoOps/contract.py:32
     // result = op.ed25519verify(a, b, c)
@@ -632,67 +661,13 @@ verify_ed25519verify:
     ed25519verify
     // tests/artifacts/CryptoOps/contract.py:33
     // return arc4.Bool(result)
-    byte 0x00
-    int 0
+    bytec_1 // 0x00
+    intc_0 // 0
     uncover 2
     setbit
     retsub
 
 
-// algopy.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
-ensure_budget:
-    // <algopy>/algopy.py:11-17
-    proto 2 0
-    // <algopy>/algopy.py:18
-    frame_dig -2
-    int 10
-    +
-
-ensure_budget_while_top@1:
-    // <algopy>/algopy.py:19
-    frame_dig 0
-    global OpcodeBudget
-    >
-    bz ensure_budget_after_while@7
-    // <algopy>/algopy.py:20
-    itxn_begin
-    // <algopy>/algopy.py:21
-    int appl
-    itxn_field TypeEnum
-    // <algopy>/algopy.py:22
-    int DeleteApplication
-    itxn_field OnCompletion
-    // <algopy>/algopy.py:23
-    byte 0x068101
-    itxn_field ApprovalProgram
-    // <algopy>/algopy.py:24
-    byte 0x068101
-    itxn_field ClearStateProgram
-    // <algopy>/algopy.py:25-29
-    frame_dig -1
-    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4
-    b ensure_budget_switch_case_next@6
-
-ensure_budget_switch_case_0@3:
-    // <algopy>/algopy.py:27
-    int 0
-    itxn_field Fee
-    b ensure_budget_switch_case_next@6
-
-ensure_budget_switch_case_1@4:
-    // <algopy>/algopy.py:29
-    global MinTxnFee
-    itxn_field Fee
-
-ensure_budget_switch_case_next@6:
-    // <algopy>/algopy.py:30
-    itxn_submit
-    b ensure_budget_while_top@1
-
-ensure_budget_after_while@7:
-    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
@@ -701,8 +676,8 @@ verify_ed25519verify_bare:
     proto 3 1
     // tests/artifacts/CryptoOps/contract.py:37
     // ensure_budget(1900, OpUpFeeSource.GroupCredit)
-    int 1900
-    int 0
+    pushint 1900 // 1900
+    intc_0 // 0
     callsub ensure_budget
     // tests/artifacts/CryptoOps/contract.py:38
     // result = op.ed25519verify_bare(a, b, c)
@@ -712,8 +687,8 @@ verify_ed25519verify_bare:
     ed25519verify_bare
     // tests/artifacts/CryptoOps/contract.py:39
     // return arc4.Bool(result)
-    byte 0x00
-    int 0
+    bytec_1 // 0x00
+    intc_0 // 0
     uncover 2
     setbit
     retsub
@@ -727,8 +702,8 @@ verify_ecdsa_verify_k1:
     proto 5 1
     // tests/artifacts/CryptoOps/contract.py:43
     // ensure_budget(3000, OpUpFeeSource.GroupCredit)
-    int 3000
-    int 0
+    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)
@@ -751,8 +726,8 @@ verify_ecdsa_verify_r1:
     proto 5 1
     // tests/artifacts/CryptoOps/contract.py:49
     // ensure_budget(3000, OpUpFeeSource.GroupCredit)
-    int 3000
-    int 0
+    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)
@@ -777,8 +752,8 @@ verify_ecdsa_recover_k1:
     proto 4 2
     // tests/artifacts/CryptoOps/contract.py:57
     // ensure_budget(3000, OpUpFeeSource.GroupCredit)
-    int 3000
-    int 0
+    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)
@@ -800,8 +775,8 @@ verify_ecdsa_recover_r1:
     proto 4 2
     // tests/artifacts/CryptoOps/contract.py:67
     // ensure_budget(3000, OpUpFeeSource.GroupCredit)
-    int 3000
-    int 0
+    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)
@@ -821,8 +796,8 @@ verify_ecdsa_decompress_k1:
     proto 1 2
     // tests/artifacts/CryptoOps/contract.py:72
     // ensure_budget(700, OpUpFeeSource.GroupCredit)
-    int 700
-    int 0
+    pushint 700 // 700
+    intc_0 // 0
     callsub ensure_budget
     // tests/artifacts/CryptoOps/contract.py:73
     // return op.ecdsa_pk_decompress(op.ECDSA.Secp256k1, a)
@@ -839,8 +814,8 @@ verify_ecdsa_decompress_r1:
     proto 1 2
     // tests/artifacts/CryptoOps/contract.py:77
     // ensure_budget(700, OpUpFeeSource.GroupCredit)
-    int 700
-    int 0
+    pushint 700 // 700
+    intc_0 // 0
     callsub ensure_budget
     // tests/artifacts/CryptoOps/contract.py:78
     // return op.ecdsa_pk_decompress(op.ECDSA.Secp256r1, a)
@@ -857,8 +832,8 @@ verify_vrf_verify:
     proto 3 2
     // tests/artifacts/CryptoOps/contract.py:82
     // ensure_budget(5700, OpUpFeeSource.GroupCredit)
-    int 5700
-    int 0
+    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)
diff --git a/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json b/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json
index 007f9f8..3e99cab 100644
--- a/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json
+++ b/tests/artifacts/CryptoOps/data/CryptoOpsContract.arc32.json
@@ -67,8 +67,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.CryptoOps.contract.CryptoOpsContract.approval_program:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@17
    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@2 main_verify_sha3_256_route@3 main_verify_keccak_256_route@4 main_verify_sha512_256_route@5 main_verify_ed25519verify_route@6 main_verify_ed25519verify_bare_route@7 main_verify_ecdsa_verify_k1_route@8 main_verify_ecdsa_verify_r1_route@9 main_verify_ecdsa_recover_k1_route@10 main_verify_ecdsa_recover_r1_route@11 main_verify_ecdsa_decompress_k1_route@12 main_verify_ecdsa_decompress_r1_route@13 main_verify_vrf_verify_route@14
    err // reject transaction

main_verify_sha256_route@2:
    // tests/artifacts/CryptoOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_sha3_256_route@3:
    // tests/artifacts/CryptoOps/contract.py:11
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_keccak_256_route@4:
    // tests/artifacts/CryptoOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_sha512_256_route@5:
    // tests/artifacts/CryptoOps/contract.py:23
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ed25519verify_route@6:
    // tests/artifacts/CryptoOps/contract.py:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ed25519verify_bare_route@7:
    // tests/artifacts/CryptoOps/contract.py:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ecdsa_verify_k1_route@8:
    // tests/artifacts/CryptoOps/contract.py:41
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ecdsa_verify_r1_route@9:
    // tests/artifacts/CryptoOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ecdsa_recover_k1_route@10:
    // tests/artifacts/CryptoOps/contract.py:53
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    swap
    dup
    len
    itob
    extract 6 2
    swap
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    dup
    len
    int 4
    +
    itob
    extract 6 2
    byte 0x0004
    swap
    concat
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ecdsa_recover_r1_route@11:
    // tests/artifacts/CryptoOps/contract.py:60
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    swap
    dup
    len
    itob
    extract 6 2
    swap
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    dup
    len
    int 4
    +
    itob
    extract 6 2
    byte 0x0004
    swap
    concat
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ecdsa_decompress_k1_route@12:
    // tests/artifacts/CryptoOps/contract.py:70
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    swap
    dup
    len
    itob
    extract 6 2
    swap
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    dup
    len
    int 4
    +
    itob
    extract 6 2
    byte 0x0004
    swap
    concat
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_ecdsa_decompress_r1_route@13:
    // tests/artifacts/CryptoOps/contract.py:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    swap
    dup
    len
    itob
    extract 6 2
    swap
    concat
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    swap
    dup
    len
    int 4
    +
    itob
    extract 6 2
    byte 0x0004
    swap
    concat
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_vrf_verify_route@14:
    // tests/artifacts/CryptoOps/contract.py:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    swap
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x00
    int 0
    uncover 3
    setbit
    byte 0x0003
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@17:
    // tests/artifacts/CryptoOps/contract.py:4
    // class CryptoOpsContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// 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)
    int 1900
    int 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)
    byte 0x00
    int 0
    uncover 2
    setbit
    retsub


// algopy.ensure_budget(required_budget: uint64, fee_source: uint64) -> void:
ensure_budget:
    // <algopy>/algopy.py:11-17
    proto 2 0
    // <algopy>/algopy.py:18
    frame_dig -2
    int 10
    +

ensure_budget_while_top@1:
    // <algopy>/algopy.py:19
    frame_dig 0
    global OpcodeBudget
    >
    bz ensure_budget_after_while@7
    // <algopy>/algopy.py:20
    itxn_begin
    // <algopy>/algopy.py:21
    int appl
    itxn_field TypeEnum
    // <algopy>/algopy.py:22
    int DeleteApplication
    itxn_field OnCompletion
    // <algopy>/algopy.py:23
    byte 0x068101
    itxn_field ApprovalProgram
    // <algopy>/algopy.py:24
    byte 0x068101
    itxn_field ClearStateProgram
    // <algopy>/algopy.py:25-29
    frame_dig -1
    switch ensure_budget_switch_case_0@3 ensure_budget_switch_case_1@4
    b ensure_budget_switch_case_next@6

ensure_budget_switch_case_0@3:
    // <algopy>/algopy.py:27
    int 0
    itxn_field Fee
    b ensure_budget_switch_case_next@6

ensure_budget_switch_case_1@4:
    // <algopy>/algopy.py:29
    global MinTxnFee
    itxn_field Fee

ensure_budget_switch_case_next@6:
    // <algopy>/algopy.py:30
    itxn_submit
    b ensure_budget_while_top@1

ensure_budget_after_while@7:
    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)
    int 1900
    int 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)
    byte 0x00
    int 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)
    int 3000
    int 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)
    int 3000
    int 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)
    int 3000
    int 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)
    int 3000
    int 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)
    int 700
    int 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)
    int 700
    int 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)
    int 5700
    int 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": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuQ3J5cHRvT3BzLmNvbnRyYWN0LkNyeXB0b09wc0NvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3J5cHRvT3BzL2NvbnRyYWN0LnB5OjQKICAgIC8vIGNsYXNzIENyeXB0b09wc0NvbnRyYWN0KEFSQzRDb250cmFjdCk6CiAgICBpbnQgMQogICAgcmV0dXJuCg=="
+        "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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/CryptoOps/data/CryptoOpsContract.clear.teal b/tests/artifacts/CryptoOps/data/CryptoOpsContract.clear.teal
index e1705b2..a433105 100644
--- a/tests/artifacts/CryptoOps/data/CryptoOpsContract.clear.teal
+++ b/tests/artifacts/CryptoOps/data/CryptoOpsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.CryptoOps.contract.CryptoOpsContract.clear_state_program:
-    // tests/artifacts/CryptoOps/contract.py:4
-    // class CryptoOpsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.approval.teal b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.approval.teal
index a0591ec..96aaf25 100644
--- a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.approval.teal
+++ b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.approval.teal
@@ -1,23 +1,32 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.GlobalStateValidator.contract.GlobalStateValidator.approval_program:
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1
+    bytecblock 0xc0eb5c67
     // tests/artifacts/GlobalStateValidator/contract.py:4
     // class GlobalStateValidator(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@5
-    method "validate_g_args(uint64,string)void"
+    bz main_bare_routing@6
+    bytec_0 // method "validate_g_args(uint64,string)void"
     txna ApplicationArgs 0
-    match main_validate_g_args_route@2
-    err // reject transaction
+    match main_validate_g_args_route@3
 
-main_validate_g_args_route@2:
+main_after_if_else@10:
+    // tests/artifacts/GlobalStateValidator/contract.py:4
+    // class GlobalStateValidator(ARC4Contract):
+    pushint 0 // 0
+    return
+
+main_validate_g_args_route@3:
     // tests/artifacts/GlobalStateValidator/contract.py:5
     // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/GlobalStateValidator/contract.py:4
     // class GlobalStateValidator(ARC4Contract):
     txna ApplicationArgs 1
@@ -25,19 +34,18 @@ main_validate_g_args_route@2:
     // tests/artifacts/GlobalStateValidator/contract.py:5
     // @arc4.abimethod
     callsub validate_g_args
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@5:
+main_bare_routing@6:
     // tests/artifacts/GlobalStateValidator/contract.py:4
     // class GlobalStateValidator(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@10
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
@@ -50,7 +58,7 @@ validate_g_args:
     // tests/artifacts/GlobalStateValidator/contract.py:7
     // assert Txn.application_args(0) == arc4.arc4_signature("validate_g_args(uint64,string)void")
     txna ApplicationArgs 0
-    method "validate_g_args(uint64,string)void"
+    bytec_0 // method "validate_g_args(uint64,string)void"
     ==
     assert
     // tests/artifacts/GlobalStateValidator/contract.py:8
@@ -70,10 +78,10 @@ validate_g_args:
     txn GroupIndex
     dup
     gtxns TypeEnum
-    int appl
+    pushint 6 // appl
     ==
     assert // transaction type is appl
-    int 1
+    intc_0 // 1
     gtxnsas ApplicationArgs
     frame_dig -2
     ==
@@ -81,7 +89,7 @@ validate_g_args:
     // tests/artifacts/GlobalStateValidator/contract.py:11
     // assert gtxn.Transaction(Txn.group_index).app_args(1) == arg1.bytes
     txn GroupIndex
-    int 1
+    intc_0 // 1
     gtxnsas ApplicationArgs
     frame_dig -2
     ==
diff --git a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc32.json b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc32.json
index 40dae7b..f9bfe8e 100644
--- a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc32.json
+++ b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.arc32.json
@@ -7,8 +7,8 @@
         }
     },
     "source": {
-        "approval": "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",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuR2xvYmFsU3RhdGVWYWxpZGF0b3IuY29udHJhY3QuR2xvYmFsU3RhdGVWYWxpZGF0b3IuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9HbG9iYWxTdGF0ZVZhbGlkYXRvci9jb250cmFjdC5weTo0CiAgICAvLyBjbGFzcyBHbG9iYWxTdGF0ZVZhbGlkYXRvcihBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.clear.teal b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.clear.teal
index 1146cbc..a433105 100644
--- a/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.clear.teal
+++ b/tests/artifacts/GlobalStateValidator/data/GlobalStateValidator.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.GlobalStateValidator.contract.GlobalStateValidator.clear_state_program:
-    // tests/artifacts/GlobalStateValidator/contract.py:4
-    // class GlobalStateValidator(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal
index 070046d..9ea557c 100644
--- a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal
+++ b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.approval.teal
@@ -1,352 +1,313 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.approval_program:
+// 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@41
-    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[]"
+    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@2 main_verify_base64_decode_standard_route@3 main_verify_base64_decode_url_route@4 main_verify_bytes_bitlen_route@5 main_verify_uint64_bitlen_route@6 main_verify_bsqrt_route@7 main_verify_btoi_route@8 main_verify_bzero_route@9 main_verify_concat_route@10 main_verify_divmodw_route@11 main_verify_divw_route@12 main_verify_err_route@13 main_verify_exp_route@14 main_verify_expw_route@15 main_verify_extract_route@16 main_verify_extract_from_2_route@17 main_verify_extract_uint16_route@18 main_verify_extract_uint32_route@19 main_verify_extract_uint64_route@20 main_verify_getbit_bytes_route@21 main_verify_getbit_uint64_route@22 main_verify_getbyte_route@23 main_verify_itob_route@24 main_verify_mulw_route@25 main_verify_replace_route@26 main_verify_select_bytes_route@27 main_verify_select_uint64_route@28 main_verify_setbit_bytes_route@29 main_verify_setbit_uint64_route@30 main_verify_setbyte_route@31 main_verify_shl_route@32 main_verify_shr_route@33 main_verify_sqrt_route@34 main_verify_substring_route@35 main_verify_json_ref_string_route@36 main_verify_json_ref_uint64_route@37 main_verify_json_ref_object_route@38
-    err // reject transaction
+    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_verify_addw_route@2:
-    // tests/artifacts/MiscellaneousOps/contract.py:5
+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 NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:5
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:191
     // @arc4.abimethod()
-    callsub verify_addw
-    swap
+    callsub verify_json_ref_object
+    dup
+    len
     itob
+    extract 6 2
     swap
-    itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_base64_decode_standard_route@3:
-    // tests/artifacts/MiscellaneousOps/contract.py:10
+main_verify_json_ref_uint64_route@38:
+    // tests/artifacts/MiscellaneousOps/contract.py:186
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:186
     // @arc4.abimethod()
-    callsub verify_base64_decode_standard
-    dup
-    len
+    callsub verify_json_ref_uint64
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_base64_decode_url_route@4:
-    // tests/artifacts/MiscellaneousOps/contract.py:15
+main_verify_json_ref_string_route@37:
+    // tests/artifacts/MiscellaneousOps/contract.py:181
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:181
     // @arc4.abimethod()
-    callsub verify_base64_decode_url
+    callsub verify_json_ref_string
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_bitlen_route@5:
-    // tests/artifacts/MiscellaneousOps/contract.py:20
+main_verify_substring_route@36:
+    // tests/artifacts/MiscellaneousOps/contract.py:176
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 3
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:176
     // @arc4.abimethod()
-    callsub verify_bytes_bitlen
+    callsub verify_substring
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_bitlen_route@6:
-    // tests/artifacts/MiscellaneousOps/contract.py:26
+main_verify_sqrt_route@35:
+    // tests/artifacts/MiscellaneousOps/contract.py:171
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:171
     // @arc4.abimethod()
-    callsub verify_uint64_bitlen
+    callsub verify_sqrt
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bsqrt_route@7:
-    // tests/artifacts/MiscellaneousOps/contract.py:31
+main_verify_shr_route@34:
+    // tests/artifacts/MiscellaneousOps/contract.py:166
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    btoi
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:166
     // @arc4.abimethod()
-    callsub verify_bsqrt
-    dup
-    len
+    callsub verify_shr
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_btoi_route@8:
-    // tests/artifacts/MiscellaneousOps/contract.py:37
+main_verify_shl_route@33:
+    // tests/artifacts/MiscellaneousOps/contract.py:161
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    btoi
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:161
     // @arc4.abimethod()
-    callsub verify_btoi
+    callsub verify_shl
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bzero_route@9:
-    // tests/artifacts/MiscellaneousOps/contract.py:42
+main_verify_setbyte_route@32:
+    // tests/artifacts/MiscellaneousOps/contract.py:156
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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:42
+    txna ApplicationArgs 3
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:156
     // @arc4.abimethod()
-    callsub verify_bzero
+    callsub verify_setbyte
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_concat_route@10:
-    // tests/artifacts/MiscellaneousOps/contract.py:47
+main_verify_setbit_uint64_route@31:
+    // tests/artifacts/MiscellaneousOps/contract.py:151
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    txna ApplicationArgs 3
     btoi
-    txna ApplicationArgs 4
+    txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:47
+    // tests/artifacts/MiscellaneousOps/contract.py:151
     // @arc4.abimethod()
-    callsub verify_concat
-    dup
-    len
+    callsub verify_setbit_uint64
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_divmodw_route@11:
-    // tests/artifacts/MiscellaneousOps/contract.py:55
+main_verify_setbit_bytes_route@30:
+    // tests/artifacts/MiscellaneousOps/contract.py:146
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
     txna ApplicationArgs 3
     btoi
-    txna ApplicationArgs 4
-    btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:55
+    // tests/artifacts/MiscellaneousOps/contract.py:146
     // @arc4.abimethod()
-    callsub verify_divmodw
-    cover 3
-    cover 2
-    swap
-    itob
-    cover 2
-    itob
-    swap
-    itob
-    swap
-    uncover 3
+    callsub verify_setbit_bytes
+    dup
+    len
     itob
-    cover 3
-    uncover 2
-    swap
-    concat
-    swap
-    concat
+    extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_divw_route@12:
-    // tests/artifacts/MiscellaneousOps/contract.py:62
+main_verify_select_uint64_route@29:
+    // tests/artifacts/MiscellaneousOps/contract.py:141
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -355,422 +316,422 @@ main_verify_divw_route@12:
     btoi
     txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:62
+    // tests/artifacts/MiscellaneousOps/contract.py:141
     // @arc4.abimethod()
-    callsub verify_divw
+    callsub verify_select_uint64
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
-    return
-
-main_verify_err_route@13:
-    // tests/artifacts/MiscellaneousOps/contract.py:67
-    // @arc4.abimethod()
-    txn OnCompletion
-    !
-    assert // OnCompletion is NoOp
-    txn ApplicationID
-    assert // is not creating
-    callsub verify_err
-    int 1
+    intc_0 // 1
     return
 
-main_verify_exp_route@14:
-    // tests/artifacts/MiscellaneousOps/contract.py:71
+main_verify_select_bytes_route@28:
+    // tests/artifacts/MiscellaneousOps/contract.py:136
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
+    extract 2 0
+    txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:71
+    // tests/artifacts/MiscellaneousOps/contract.py:136
     // @arc4.abimethod()
-    callsub verify_exp
+    callsub verify_select_bytes
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_expw_route@15:
-    // tests/artifacts/MiscellaneousOps/contract.py:76
+main_verify_replace_route@27:
+    // tests/artifacts/MiscellaneousOps/contract.py:131
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:76
+    txna ApplicationArgs 3
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:131
     // @arc4.abimethod()
-    callsub verify_expw
-    swap
+    callsub verify_replace
+    dup
+    len
     itob
+    extract 6 2
     swap
-    itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_extract_route@16:
-    // tests/artifacts/MiscellaneousOps/contract.py:81
+main_verify_mulw_route@26:
+    // tests/artifacts/MiscellaneousOps/contract.py:126
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    txna ApplicationArgs 2
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:81
+    // tests/artifacts/MiscellaneousOps/contract.py:126
     // @arc4.abimethod()
-    callsub verify_extract
-    dup
-    len
+    callsub verify_mulw
+    swap
     itob
-    extract 6 2
     swap
+    itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_extract_from_2_route@17:
-    // tests/artifacts/MiscellaneousOps/contract.py:86
+main_verify_itob_route@25:
+    // tests/artifacts/MiscellaneousOps/contract.py:121
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:121
     // @arc4.abimethod()
-    callsub verify_extract_from_2
+    callsub verify_itob
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_extract_uint16_route@18:
-    // tests/artifacts/MiscellaneousOps/contract.py:91
+main_verify_getbyte_route@24:
+    // tests/artifacts/MiscellaneousOps/contract.py:116
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:116
     // @arc4.abimethod()
-    callsub verify_extract_uint16
+    callsub verify_getbyte
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_extract_uint32_route@19:
-    // tests/artifacts/MiscellaneousOps/contract.py:96
+main_verify_getbit_uint64_route@23:
+    // tests/artifacts/MiscellaneousOps/contract.py:111
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:96
+    // tests/artifacts/MiscellaneousOps/contract.py:111
     // @arc4.abimethod()
-    callsub verify_extract_uint32
+    callsub verify_getbit_uint64
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_extract_uint64_route@20:
-    // tests/artifacts/MiscellaneousOps/contract.py:101
+main_verify_getbit_bytes_route@22:
+    // tests/artifacts/MiscellaneousOps/contract.py:106
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:106
     // @arc4.abimethod()
-    callsub verify_extract_uint64
+    callsub verify_getbit_bytes
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_getbit_bytes_route@21:
-    // tests/artifacts/MiscellaneousOps/contract.py:106
+main_verify_extract_uint64_route@21:
+    // tests/artifacts/MiscellaneousOps/contract.py:101
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:101
     // @arc4.abimethod()
-    callsub verify_getbit_bytes
+    callsub verify_extract_uint64
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_getbit_uint64_route@22:
-    // tests/artifacts/MiscellaneousOps/contract.py:111
+main_verify_extract_uint32_route@20:
+    // tests/artifacts/MiscellaneousOps/contract.py:96
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:111
+    // tests/artifacts/MiscellaneousOps/contract.py:96
     // @arc4.abimethod()
-    callsub verify_getbit_uint64
+    callsub verify_extract_uint32
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_getbyte_route@23:
-    // tests/artifacts/MiscellaneousOps/contract.py:116
+main_verify_extract_uint16_route@19:
+    // tests/artifacts/MiscellaneousOps/contract.py:91
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:91
     // @arc4.abimethod()
-    callsub verify_getbyte
+    callsub verify_extract_uint16
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_itob_route@24:
-    // tests/artifacts/MiscellaneousOps/contract.py:121
+main_verify_extract_from_2_route@18:
+    // tests/artifacts/MiscellaneousOps/contract.py:86
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:86
     // @arc4.abimethod()
-    callsub verify_itob
+    callsub verify_extract_from_2
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_mulw_route@25:
-    // tests/artifacts/MiscellaneousOps/contract.py:126
+main_verify_extract_route@17:
+    // tests/artifacts/MiscellaneousOps/contract.py:81
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:126
+    txna ApplicationArgs 3
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:81
     // @arc4.abimethod()
-    callsub verify_mulw
-    swap
+    callsub verify_extract
+    dup
+    len
     itob
+    extract 6 2
     swap
-    itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_replace_route@26:
-    // tests/artifacts/MiscellaneousOps/contract.py:131
+main_verify_expw_route@16:
+    // tests/artifacts/MiscellaneousOps/contract.py:76
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    txna ApplicationArgs 3
-    extract 2 0
-    // tests/artifacts/MiscellaneousOps/contract.py:131
+    // tests/artifacts/MiscellaneousOps/contract.py:76
     // @arc4.abimethod()
-    callsub verify_replace
-    dup
-    len
+    callsub verify_expw
+    swap
     itob
-    extract 6 2
     swap
+    itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_select_bytes_route@27:
-    // tests/artifacts/MiscellaneousOps/contract.py:136
+main_verify_exp_route@15:
+    // tests/artifacts/MiscellaneousOps/contract.py:71
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:136
+    // tests/artifacts/MiscellaneousOps/contract.py:71
     // @arc4.abimethod()
-    callsub verify_select_bytes
-    dup
-    len
+    callsub verify_exp
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_select_uint64_route@28:
-    // tests/artifacts/MiscellaneousOps/contract.py:141
+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 NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -779,308 +740,315 @@ main_verify_select_uint64_route@28:
     btoi
     txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:141
+    // tests/artifacts/MiscellaneousOps/contract.py:62
     // @arc4.abimethod()
-    callsub verify_select_uint64
+    callsub verify_divw
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_setbit_bytes_route@29:
-    // tests/artifacts/MiscellaneousOps/contract.py:146
+main_verify_divmodw_route@12:
+    // tests/artifacts/MiscellaneousOps/contract.py:55
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
     txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:146
+    txna ApplicationArgs 4
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:55
     // @arc4.abimethod()
-    callsub verify_setbit_bytes
-    dup
-    len
+    callsub verify_divmodw
+    uncover 3
     itob
-    extract 6 2
+    uncover 3
+    itob
+    uncover 3
+    itob
+    uncover 3
+    itob
+    uncover 3
+    uncover 3
+    concat
+    uncover 2
+    concat
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_setbit_uint64_route@30:
-    // tests/artifacts/MiscellaneousOps/contract.py:151
+main_verify_concat_route@11:
+    // tests/artifacts/MiscellaneousOps/contract.py:47
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
+    extract 2 0
     txna ApplicationArgs 3
     btoi
-    // tests/artifacts/MiscellaneousOps/contract.py:151
+    txna ApplicationArgs 4
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:47
     // @arc4.abimethod()
-    callsub verify_setbit_uint64
+    callsub verify_concat
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_setbyte_route@31:
-    // tests/artifacts/MiscellaneousOps/contract.py:156
+main_verify_bzero_route@10:
+    // tests/artifacts/MiscellaneousOps/contract.py:42
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:42
     // @arc4.abimethod()
-    callsub verify_setbyte
+    callsub verify_bzero
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_shl_route@32:
-    // tests/artifacts/MiscellaneousOps/contract.py:161
+main_verify_btoi_route@9:
+    // tests/artifacts/MiscellaneousOps/contract.py:37
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:37
     // @arc4.abimethod()
-    callsub verify_shl
+    callsub verify_btoi
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_shr_route@33:
-    // tests/artifacts/MiscellaneousOps/contract.py:166
+main_verify_bsqrt_route@8:
+    // tests/artifacts/MiscellaneousOps/contract.py:31
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    extract 2 0
+    // tests/artifacts/MiscellaneousOps/contract.py:31
     // @arc4.abimethod()
-    callsub verify_shr
+    callsub verify_bsqrt
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_sqrt_route@34:
-    // tests/artifacts/MiscellaneousOps/contract.py:171
+main_verify_uint64_bitlen_route@7:
+    // tests/artifacts/MiscellaneousOps/contract.py:26
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:26
     // @arc4.abimethod()
-    callsub verify_sqrt
+    callsub verify_uint64_bitlen
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_substring_route@35:
-    // tests/artifacts/MiscellaneousOps/contract.py:176
+main_verify_bytes_bitlen_route@6:
+    // tests/artifacts/MiscellaneousOps/contract.py:20
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:20
     // @arc4.abimethod()
-    callsub verify_substring
-    dup
-    len
+    callsub verify_bytes_bitlen
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_json_ref_string_route@36:
-    // tests/artifacts/MiscellaneousOps/contract.py:181
+main_verify_base64_decode_url_route@5:
+    // tests/artifacts/MiscellaneousOps/contract.py:15
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:15
     // @arc4.abimethod()
-    callsub verify_json_ref_string
+    callsub verify_base64_decode_url
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_json_ref_uint64_route@37:
-    // tests/artifacts/MiscellaneousOps/contract.py:186
+main_verify_base64_decode_standard_route@4:
+    // tests/artifacts/MiscellaneousOps/contract.py:10
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    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
+    // tests/artifacts/MiscellaneousOps/contract.py:10
     // @arc4.abimethod()
-    callsub verify_json_ref_uint64
+    callsub verify_base64_decode_standard
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_json_ref_object_route@38:
-    // tests/artifacts/MiscellaneousOps/contract.py:191
+main_verify_addw_route@3:
+    // tests/artifacts/MiscellaneousOps/contract.py:5
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/MiscellaneousOps/contract.py:191
+    btoi
+    // tests/artifacts/MiscellaneousOps/contract.py:5
     // @arc4.abimethod()
-    callsub verify_json_ref_object
-    dup
-    len
+    callsub verify_addw
+    swap
     itob
-    extract 6 2
     swap
+    itob
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@41:
+main_bare_routing@42:
     // tests/artifacts/MiscellaneousOps/contract.py:4
     // class MiscellaneousOpsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@46
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
@@ -1283,17 +1251,6 @@ verify_divw:
     retsub
 
 
-// tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_err() -> void:
-verify_err:
-    // tests/artifacts/MiscellaneousOps/contract.py:67-68
-    // @arc4.abimethod()
-    // def verify_err(self) -> None:
-    proto 0 0
-    // tests/artifacts/MiscellaneousOps/contract.py:69
-    // op.err()
-    err
-
-
 // tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
 verify_exp:
     // tests/artifacts/MiscellaneousOps/contract.py:71-72
diff --git a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json
index 8a3e7d8..b23b43f 100644
--- a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json
+++ b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.arc32.json
@@ -187,8 +187,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.approval_program:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@41
    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@2 main_verify_base64_decode_standard_route@3 main_verify_base64_decode_url_route@4 main_verify_bytes_bitlen_route@5 main_verify_uint64_bitlen_route@6 main_verify_bsqrt_route@7 main_verify_btoi_route@8 main_verify_bzero_route@9 main_verify_concat_route@10 main_verify_divmodw_route@11 main_verify_divw_route@12 main_verify_err_route@13 main_verify_exp_route@14 main_verify_expw_route@15 main_verify_extract_route@16 main_verify_extract_from_2_route@17 main_verify_extract_uint16_route@18 main_verify_extract_uint32_route@19 main_verify_extract_uint64_route@20 main_verify_getbit_bytes_route@21 main_verify_getbit_uint64_route@22 main_verify_getbyte_route@23 main_verify_itob_route@24 main_verify_mulw_route@25 main_verify_replace_route@26 main_verify_select_bytes_route@27 main_verify_select_uint64_route@28 main_verify_setbit_bytes_route@29 main_verify_setbit_uint64_route@30 main_verify_setbyte_route@31 main_verify_shl_route@32 main_verify_shr_route@33 main_verify_sqrt_route@34 main_verify_substring_route@35 main_verify_json_ref_string_route@36 main_verify_json_ref_uint64_route@37 main_verify_json_ref_object_route@38
    err // reject transaction

main_verify_addw_route@2:
    // tests/artifacts/MiscellaneousOps/contract.py:5
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_base64_decode_standard_route@3:
    // tests/artifacts/MiscellaneousOps/contract.py:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_base64_decode_url_route@4:
    // tests/artifacts/MiscellaneousOps/contract.py:15
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_bitlen_route@5:
    // tests/artifacts/MiscellaneousOps/contract.py:20
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_bitlen_route@6:
    // tests/artifacts/MiscellaneousOps/contract.py:26
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bsqrt_route@7:
    // tests/artifacts/MiscellaneousOps/contract.py:31
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_btoi_route@8:
    // tests/artifacts/MiscellaneousOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bzero_route@9:
    // tests/artifacts/MiscellaneousOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_concat_route@10:
    // tests/artifacts/MiscellaneousOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_divmodw_route@11:
    // tests/artifacts/MiscellaneousOps/contract.py:55
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    cover 3
    cover 2
    swap
    itob
    cover 2
    itob
    swap
    itob
    swap
    uncover 3
    itob
    cover 3
    uncover 2
    swap
    concat
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_divw_route@12:
    // tests/artifacts/MiscellaneousOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_err_route@13:
    // tests/artifacts/MiscellaneousOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub verify_err
    int 1
    return

main_verify_exp_route@14:
    // tests/artifacts/MiscellaneousOps/contract.py:71
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_expw_route@15:
    // tests/artifacts/MiscellaneousOps/contract.py:76
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_extract_route@16:
    // tests/artifacts/MiscellaneousOps/contract.py:81
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_extract_from_2_route@17:
    // tests/artifacts/MiscellaneousOps/contract.py:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_extract_uint16_route@18:
    // tests/artifacts/MiscellaneousOps/contract.py:91
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_extract_uint32_route@19:
    // tests/artifacts/MiscellaneousOps/contract.py:96
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_extract_uint64_route@20:
    // tests/artifacts/MiscellaneousOps/contract.py:101
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_getbit_bytes_route@21:
    // tests/artifacts/MiscellaneousOps/contract.py:106
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_getbit_uint64_route@22:
    // tests/artifacts/MiscellaneousOps/contract.py:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_getbyte_route@23:
    // tests/artifacts/MiscellaneousOps/contract.py:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_itob_route@24:
    // tests/artifacts/MiscellaneousOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_mulw_route@25:
    // tests/artifacts/MiscellaneousOps/contract.py:126
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_replace_route@26:
    // tests/artifacts/MiscellaneousOps/contract.py:131
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_select_bytes_route@27:
    // tests/artifacts/MiscellaneousOps/contract.py:136
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_select_uint64_route@28:
    // tests/artifacts/MiscellaneousOps/contract.py:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_setbit_bytes_route@29:
    // tests/artifacts/MiscellaneousOps/contract.py:146
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_setbit_uint64_route@30:
    // tests/artifacts/MiscellaneousOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_setbyte_route@31:
    // tests/artifacts/MiscellaneousOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_shl_route@32:
    // tests/artifacts/MiscellaneousOps/contract.py:161
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_shr_route@33:
    // tests/artifacts/MiscellaneousOps/contract.py:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_sqrt_route@34:
    // tests/artifacts/MiscellaneousOps/contract.py:171
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_substring_route@35:
    // tests/artifacts/MiscellaneousOps/contract.py:176
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_json_ref_string_route@36:
    // tests/artifacts/MiscellaneousOps/contract.py:181
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_json_ref_uint64_route@37:
    // tests/artifacts/MiscellaneousOps/contract.py:186
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_json_ref_object_route@38:
    // tests/artifacts/MiscellaneousOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is 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
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@41:
    // tests/artifacts/MiscellaneousOps/contract.py:4
    // class MiscellaneousOpsContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 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_err() -> void:
verify_err:
    // tests/artifacts/MiscellaneousOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_err(self) -> None:
    proto 0 0
    // tests/artifacts/MiscellaneousOps/contract.py:69
    // op.err()
    err


// 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": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuTWlzY2VsbGFuZW91c09wcy5jb250cmFjdC5NaXNjZWxsYW5lb3VzT3BzQ29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9NaXNjZWxsYW5lb3VzT3BzL2NvbnRyYWN0LnB5OjQKICAgIC8vIGNsYXNzIE1pc2NlbGxhbmVvdXNPcHNDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.clear.teal b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.clear.teal
index 69f45be..a433105 100644
--- a/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.clear.teal
+++ b/tests/artifacts/MiscellaneousOps/data/MiscellaneousOpsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.MiscellaneousOps.contract.MiscellaneousOpsContract.clear_state_program:
-    // tests/artifacts/MiscellaneousOps/contract.py:4
-    // class MiscellaneousOpsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.approval.teal b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.approval.teal
index 058b711..95304ba 100644
--- a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.approval.teal
+++ b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.approval.teal
@@ -1,899 +1,878 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.approval_program:
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75 0x00 "-"
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@64
-    method "verify_uint64_init(byte[])uint64"
-    method "verify_uint64_add(uint64,uint64)uint64"
-    method "verify_uint64_sub(uint64,uint64)uint64"
-    method "verify_uint64_mul(uint64,uint64)uint64"
-    method "verify_uint64_div(uint64,uint64)uint64"
-    method "verify_uint64_mod(uint64,uint64)uint64"
-    method "verify_uint64_and(uint64,uint64)uint64"
-    method "verify_uint64_or(uint64,uint64)uint64"
-    method "verify_uint64_xor(uint64,uint64)uint64"
-    method "verify_uint64_not(uint64)uint64"
-    method "verify_uint64_lshift(uint64,uint64)uint64"
-    method "verify_uint64_rshift(uint64,uint64)uint64"
-    method "verify_uint64_pow(uint64,uint64)uint64"
-    method "verify_uint64_eq(uint64,uint64)bool"
-    method "verify_uint64_ne(uint64,uint64)bool"
-    method "verify_uint64_lt(uint64,uint64)bool"
-    method "verify_uint64_le(uint64,uint64)bool"
-    method "verify_uint64_gt(uint64,uint64)bool"
-    method "verify_uint64_ge(uint64,uint64)bool"
-    method "verify_bytes_init(uint64)byte[]"
-    method "verify_bytes_add(byte[],byte[],uint64,uint64)byte[]"
-    method "verify_bytes_eq(byte[],byte[])bool"
-    method "verify_bytes_ne(byte[],byte[])bool"
-    method "verify_bytes_and(byte[],byte[])byte[]"
-    method "verify_bytes_or(byte[],byte[])byte[]"
-    method "verify_bytes_xor(byte[],byte[])byte[]"
-    method "verify_bytes_not(byte[],uint64)byte[]"
-    method "verify_biguint_add(byte[],byte[])byte[]"
-    method "verify_biguint_add_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_sub(byte[],byte[])byte[]"
-    method "verify_biguint_sub_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_mul(byte[],byte[])byte[]"
-    method "verify_biguint_mul_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_div(byte[],byte[])byte[]"
-    method "verify_biguint_div_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_mod(byte[],byte[])byte[]"
-    method "verify_biguint_mod_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_and(byte[],byte[])byte[]"
-    method "verify_biguint_and_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_or(byte[],byte[])byte[]"
-    method "verify_biguint_or_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_xor(byte[],byte[])byte[]"
-    method "verify_biguint_xor_uint64(byte[],uint64)byte[]"
-    method "verify_biguint_eq(byte[],byte[])bool"
-    method "verify_biguint_eq_uint64(byte[],uint64)bool"
-    method "verify_biguint_ne(byte[],byte[])bool"
-    method "verify_biguint_ne_uint64(byte[],uint64)bool"
-    method "verify_biguint_lt(byte[],byte[])bool"
-    method "verify_biguint_lt_uint64(byte[],uint64)bool"
-    method "verify_biguint_le(byte[],byte[])bool"
-    method "verify_biguint_le_uint64(byte[],uint64)bool"
-    method "verify_biguint_gt(byte[],byte[])bool"
-    method "verify_biguint_gt_uint64(byte[],uint64)bool"
-    method "verify_biguint_ge(byte[],byte[])bool"
-    method "verify_biguint_ge_uint64(byte[],uint64)bool"
-    method "verify_string_init(string)string"
-    method "verify_string_startswith(string,string)bool"
-    method "verify_string_endswith(string,string)bool"
-    method "verify_string_join(string,string)string"
-    method "verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[])void"
+    bz main_bare_routing@65
+    pushbytess 0x725c692b 0x17314559 0x53f34893 0x88c8b269 0xa464b7ab 0x9c8b11b8 0x6f40654e 0xec9a2974 0xc793708f 0x7ddb7499 0xa21c443d 0x6e7fb212 0xb007fcb0 0x2ebc20d4 0xb0954b66 0xdd140aef 0xace474da 0xba694990 0x6db581c0 0x91c8db89 0xdbe77158 0x9a0f22e1 0x64033d37 0x2a7237c5 0xe3a94458 0x42f87f7d 0x2b5542a4 0x9be2fbe9 0x1cd92515 0x64e1705c 0xf1271c50 0x2ab63b70 0x834bb7d2 0x531620d7 0x3fb9e769 0xfa8db0bc 0xa72ea485 0xb7b0ba19 0x74460c42 0xab320738 0x52ad4654 0x10156399 0x0f075957 0xbd843dff 0xb377d381 0x89767265 0x456b4b23 0x33d1b88c 0x6bf973ea 0x67cd6bb2 0x3f58805a 0x1e130039 0x509dc91d 0xa564a202 0x23650763 0xf8c8f8d5 0x23faf7a4 0x7d0afe15 0x48581adf 0xe007c10b // method "verify_uint64_init(byte[])uint64", method "verify_uint64_add(uint64,uint64)uint64", method "verify_uint64_sub(uint64,uint64)uint64", method "verify_uint64_mul(uint64,uint64)uint64", method "verify_uint64_div(uint64,uint64)uint64", method "verify_uint64_mod(uint64,uint64)uint64", method "verify_uint64_and(uint64,uint64)uint64", method "verify_uint64_or(uint64,uint64)uint64", method "verify_uint64_xor(uint64,uint64)uint64", method "verify_uint64_not(uint64)uint64", method "verify_uint64_lshift(uint64,uint64)uint64", method "verify_uint64_rshift(uint64,uint64)uint64", method "verify_uint64_pow(uint64,uint64)uint64", method "verify_uint64_eq(uint64,uint64)bool", method "verify_uint64_ne(uint64,uint64)bool", method "verify_uint64_lt(uint64,uint64)bool", method "verify_uint64_le(uint64,uint64)bool", method "verify_uint64_gt(uint64,uint64)bool", method "verify_uint64_ge(uint64,uint64)bool", method "verify_bytes_init(uint64)byte[]", method "verify_bytes_add(byte[],byte[],uint64,uint64)byte[]", method "verify_bytes_eq(byte[],byte[])bool", method "verify_bytes_ne(byte[],byte[])bool", method "verify_bytes_and(byte[],byte[])byte[]", method "verify_bytes_or(byte[],byte[])byte[]", method "verify_bytes_xor(byte[],byte[])byte[]", method "verify_bytes_not(byte[],uint64)byte[]", method "verify_biguint_add(byte[],byte[])byte[]", method "verify_biguint_add_uint64(byte[],uint64)byte[]", method "verify_biguint_sub(byte[],byte[])byte[]", method "verify_biguint_sub_uint64(byte[],uint64)byte[]", method "verify_biguint_mul(byte[],byte[])byte[]", method "verify_biguint_mul_uint64(byte[],uint64)byte[]", method "verify_biguint_div(byte[],byte[])byte[]", method "verify_biguint_div_uint64(byte[],uint64)byte[]", method "verify_biguint_mod(byte[],byte[])byte[]", method "verify_biguint_mod_uint64(byte[],uint64)byte[]", method "verify_biguint_and(byte[],byte[])byte[]", method "verify_biguint_and_uint64(byte[],uint64)byte[]", method "verify_biguint_or(byte[],byte[])byte[]", method "verify_biguint_or_uint64(byte[],uint64)byte[]", method "verify_biguint_xor(byte[],byte[])byte[]", method "verify_biguint_xor_uint64(byte[],uint64)byte[]", method "verify_biguint_eq(byte[],byte[])bool", method "verify_biguint_eq_uint64(byte[],uint64)bool", method "verify_biguint_ne(byte[],byte[])bool", method "verify_biguint_ne_uint64(byte[],uint64)bool", method "verify_biguint_lt(byte[],byte[])bool", method "verify_biguint_lt_uint64(byte[],uint64)bool", method "verify_biguint_le(byte[],byte[])bool", method "verify_biguint_le_uint64(byte[],uint64)bool", method "verify_biguint_gt(byte[],byte[])bool", method "verify_biguint_gt_uint64(byte[],uint64)bool", method "verify_biguint_ge(byte[],byte[])bool", method "verify_biguint_ge_uint64(byte[],uint64)bool", method "verify_string_init(string)string", method "verify_string_startswith(string,string)bool", method "verify_string_endswith(string,string)bool", method "verify_string_join(string,string)string", method "verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[])void"
     txna ApplicationArgs 0
-    match main_verify_uint64_init_route@2 main_verify_uint64_add_route@3 main_verify_uint64_sub_route@4 main_verify_uint64_mul_route@5 main_verify_uint64_div_route@6 main_verify_uint64_mod_route@7 main_verify_uint64_and_route@8 main_verify_uint64_or_route@9 main_verify_uint64_xor_route@10 main_verify_uint64_not_route@11 main_verify_uint64_lshift_route@12 main_verify_uint64_rshift_route@13 main_verify_uint64_pow_route@14 main_verify_uint64_eq_route@15 main_verify_uint64_ne_route@16 main_verify_uint64_lt_route@17 main_verify_uint64_le_route@18 main_verify_uint64_gt_route@19 main_verify_uint64_ge_route@20 main_verify_bytes_init_route@21 main_verify_bytes_add_route@22 main_verify_bytes_eq_route@23 main_verify_bytes_ne_route@24 main_verify_bytes_and_route@25 main_verify_bytes_or_route@26 main_verify_bytes_xor_route@27 main_verify_bytes_not_route@28 main_verify_biguint_add_route@29 main_verify_biguint_add_uint64_route@30 main_verify_biguint_sub_route@31 main_verify_biguint_sub_uint64_route@32 main_verify_biguint_mul_route@33 main_verify_biguint_mul_uint64_route@34 main_verify_biguint_div_route@35 main_verify_biguint_div_uint64_route@36 main_verify_biguint_mod_route@37 main_verify_biguint_mod_uint64_route@38 main_verify_biguint_and_route@39 main_verify_biguint_and_uint64_route@40 main_verify_biguint_or_route@41 main_verify_biguint_or_uint64_route@42 main_verify_biguint_xor_route@43 main_verify_biguint_xor_uint64_route@44 main_verify_biguint_eq_route@45 main_verify_biguint_eq_uint64_route@46 main_verify_biguint_ne_route@47 main_verify_biguint_ne_uint64_route@48 main_verify_biguint_lt_route@49 main_verify_biguint_lt_uint64_route@50 main_verify_biguint_le_route@51 main_verify_biguint_le_uint64_route@52 main_verify_biguint_gt_route@53 main_verify_biguint_gt_uint64_route@54 main_verify_biguint_ge_route@55 main_verify_biguint_ge_uint64_route@56 main_verify_string_init_route@57 main_verify_string_startswith_route@58 main_verify_string_endswith_route@59 main_verify_string_join_route@60 main_verify_log_route@61
-    err // reject transaction
+    match main_verify_uint64_init_route@3 main_verify_uint64_add_route@4 main_verify_uint64_sub_route@5 main_verify_uint64_mul_route@6 main_verify_uint64_div_route@7 main_verify_uint64_mod_route@8 main_verify_uint64_and_route@9 main_verify_uint64_or_route@10 main_verify_uint64_xor_route@11 main_verify_uint64_not_route@12 main_verify_uint64_lshift_route@13 main_verify_uint64_rshift_route@14 main_verify_uint64_pow_route@15 main_verify_uint64_eq_route@16 main_verify_uint64_ne_route@17 main_verify_uint64_lt_route@18 main_verify_uint64_le_route@19 main_verify_uint64_gt_route@20 main_verify_uint64_ge_route@21 main_verify_bytes_init_route@22 main_verify_bytes_add_route@23 main_verify_bytes_eq_route@24 main_verify_bytes_ne_route@25 main_verify_bytes_and_route@26 main_verify_bytes_or_route@27 main_verify_bytes_xor_route@28 main_verify_bytes_not_route@29 main_verify_biguint_add_route@30 main_verify_biguint_add_uint64_route@31 main_verify_biguint_sub_route@32 main_verify_biguint_sub_uint64_route@33 main_verify_biguint_mul_route@34 main_verify_biguint_mul_uint64_route@35 main_verify_biguint_div_route@36 main_verify_biguint_div_uint64_route@37 main_verify_biguint_mod_route@38 main_verify_biguint_mod_uint64_route@39 main_verify_biguint_and_route@40 main_verify_biguint_and_uint64_route@41 main_verify_biguint_or_route@42 main_verify_biguint_or_uint64_route@43 main_verify_biguint_xor_route@44 main_verify_biguint_xor_uint64_route@45 main_verify_biguint_eq_route@46 main_verify_biguint_eq_uint64_route@47 main_verify_biguint_ne_route@48 main_verify_biguint_ne_uint64_route@49 main_verify_biguint_lt_route@50 main_verify_biguint_lt_uint64_route@51 main_verify_biguint_le_route@52 main_verify_biguint_le_uint64_route@53 main_verify_biguint_gt_route@54 main_verify_biguint_gt_uint64_route@55 main_verify_biguint_ge_route@56 main_verify_biguint_ge_uint64_route@57 main_verify_string_init_route@58 main_verify_string_startswith_route@59 main_verify_string_endswith_route@60 main_verify_string_join_route@61 main_verify_log_route@62
 
-main_verify_uint64_init_route@2:
-    // tests/artifacts/PrimitiveOps/contract.py:7
-    // @arc4.abimethod()
-    txn OnCompletion
-    !
-    assert // OnCompletion is NoOp
-    txn ApplicationID
-    assert // is not creating
+main_after_if_else@69:
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
-    txna ApplicationArgs 1
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:7
-    // @arc4.abimethod()
-    callsub verify_uint64_init
-    itob
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    intc_1 // 0
     return
 
-main_verify_uint64_add_route@3:
-    // tests/artifacts/PrimitiveOps/contract.py:12
-    // @arc4.abimethod()
+main_verify_log_route@62:
+    // tests/artifacts/PrimitiveOps/contract.py:351
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:12
-    // @arc4.abimethod()
-    callsub verify_uint64_add
-    itob
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    txna ApplicationArgs 3
+    extract 2 0
+    txna ApplicationArgs 4
+    extract 2 0
+    txna ApplicationArgs 5
+    txna ApplicationArgs 6
+    txna ApplicationArgs 7
+    txna ApplicationArgs 8
+    txna ApplicationArgs 9
+    txna ApplicationArgs 10
+    txna ApplicationArgs 11
+    extract 2 0
+    txna ApplicationArgs 12
+    extract 2 0
+    txna ApplicationArgs 13
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:351
+    // @arc4.abimethod
+    callsub verify_log
+    intc_0 // 1
     return
 
-main_verify_uint64_sub_route@4:
-    // tests/artifacts/PrimitiveOps/contract.py:17
-    // @arc4.abimethod()
+main_verify_string_join_route@61:
+    // tests/artifacts/PrimitiveOps/contract.py:346
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:17
-    // @arc4.abimethod()
-    callsub verify_uint64_sub
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:346
+    // @arc4.abimethod
+    callsub verify_string_join
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_mul_route@5:
-    // tests/artifacts/PrimitiveOps/contract.py:22
-    // @arc4.abimethod()
+main_verify_string_endswith_route@60:
+    // tests/artifacts/PrimitiveOps/contract.py:341
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:22
-    // @arc4.abimethod()
-    callsub verify_uint64_mul
-    itob
-    byte 0x151f7c75
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:341
+    // @arc4.abimethod
+    callsub verify_string_endswith
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_div_route@6:
-    // tests/artifacts/PrimitiveOps/contract.py:27
-    // @arc4.abimethod()
+main_verify_string_startswith_route@59:
+    // tests/artifacts/PrimitiveOps/contract.py:336
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:27
-    // @arc4.abimethod()
-    callsub verify_uint64_div
-    itob
-    byte 0x151f7c75
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:336
+    // @arc4.abimethod
+    callsub verify_string_startswith
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_mod_route@7:
-    // tests/artifacts/PrimitiveOps/contract.py:32
-    // @arc4.abimethod()
+main_verify_string_init_route@58:
+    // tests/artifacts/PrimitiveOps/contract.py:331
+    // @arc4.abimethod
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
-    txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:32
-    // @arc4.abimethod()
-    callsub verify_uint64_mod
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:331
+    // @arc4.abimethod
+    callsub verify_string_init
+    dup
+    len
     itob
-    byte 0x151f7c75
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_and_route@8:
-    // tests/artifacts/PrimitiveOps/contract.py:37
+main_verify_biguint_ge_uint64_route@57:
+    // tests/artifacts/PrimitiveOps/contract.py:325
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:37
+    // tests/artifacts/PrimitiveOps/contract.py:325
     // @arc4.abimethod()
-    callsub verify_uint64_and
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_ge_uint64
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_or_route@9:
-    // tests/artifacts/PrimitiveOps/contract.py:42
+main_verify_biguint_ge_route@56:
+    // tests/artifacts/PrimitiveOps/contract.py:318
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:42
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:318
     // @arc4.abimethod()
-    callsub verify_uint64_or
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_ge
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_xor_route@10:
-    // tests/artifacts/PrimitiveOps/contract.py:47
+main_verify_biguint_gt_uint64_route@55:
+    // tests/artifacts/PrimitiveOps/contract.py:312
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:47
+    // tests/artifacts/PrimitiveOps/contract.py:312
     // @arc4.abimethod()
-    callsub verify_uint64_xor
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_gt_uint64
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_not_route@11:
-    // tests/artifacts/PrimitiveOps/contract.py:52
+main_verify_biguint_gt_route@54:
+    // tests/artifacts/PrimitiveOps/contract.py:305
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:52
+    extract 2 0
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:305
     // @arc4.abimethod()
-    callsub verify_uint64_not
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_gt
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_lshift_route@12:
-    // tests/artifacts/PrimitiveOps/contract.py:57
+main_verify_biguint_le_uint64_route@53:
+    // tests/artifacts/PrimitiveOps/contract.py:299
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:57
+    // tests/artifacts/PrimitiveOps/contract.py:299
     // @arc4.abimethod()
-    callsub verify_uint64_lshift
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_le_uint64
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_rshift_route@13:
-    // tests/artifacts/PrimitiveOps/contract.py:62
+main_verify_biguint_le_route@52:
+    // tests/artifacts/PrimitiveOps/contract.py:292
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:62
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:292
     // @arc4.abimethod()
-    callsub verify_uint64_rshift
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_le
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_pow_route@14:
-    // tests/artifacts/PrimitiveOps/contract.py:67
+main_verify_biguint_lt_uint64_route@51:
+    // tests/artifacts/PrimitiveOps/contract.py:286
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:67
+    // tests/artifacts/PrimitiveOps/contract.py:286
     // @arc4.abimethod()
-    callsub verify_uint64_pow
-    itob
-    byte 0x151f7c75
+    callsub verify_biguint_lt_uint64
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_eq_route@15:
-    // tests/artifacts/PrimitiveOps/contract.py:72
+main_verify_biguint_lt_route@50:
+    // tests/artifacts/PrimitiveOps/contract.py:279
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:72
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:279
     // @arc4.abimethod()
-    callsub verify_uint64_eq
-    byte 0x00
-    int 0
+    callsub verify_biguint_lt
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_ne_route@16:
-    // tests/artifacts/PrimitiveOps/contract.py:77
+main_verify_biguint_ne_uint64_route@49:
+    // tests/artifacts/PrimitiveOps/contract.py:273
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:77
+    // tests/artifacts/PrimitiveOps/contract.py:273
     // @arc4.abimethod()
-    callsub verify_uint64_ne
-    byte 0x00
-    int 0
+    callsub verify_biguint_ne_uint64
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_lt_route@17:
-    // tests/artifacts/PrimitiveOps/contract.py:82
+main_verify_biguint_ne_route@48:
+    // tests/artifacts/PrimitiveOps/contract.py:266
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:82
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:266
     // @arc4.abimethod()
-    callsub verify_uint64_lt
-    byte 0x00
-    int 0
+    callsub verify_biguint_ne
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_le_route@18:
-    // tests/artifacts/PrimitiveOps/contract.py:87
+main_verify_biguint_eq_uint64_route@47:
+    // tests/artifacts/PrimitiveOps/contract.py:260
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:87
+    // tests/artifacts/PrimitiveOps/contract.py:260
     // @arc4.abimethod()
-    callsub verify_uint64_le
-    byte 0x00
-    int 0
+    callsub verify_biguint_eq_uint64
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_gt_route@19:
-    // tests/artifacts/PrimitiveOps/contract.py:92
+main_verify_biguint_eq_route@46:
+    // tests/artifacts/PrimitiveOps/contract.py:253
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:92
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:253
     // @arc4.abimethod()
-    callsub verify_uint64_gt
-    byte 0x00
-    int 0
+    callsub verify_biguint_eq
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_uint64_ge_route@20:
-    // tests/artifacts/PrimitiveOps/contract.py:97
+main_verify_biguint_xor_uint64_route@45:
+    // tests/artifacts/PrimitiveOps/contract.py:247
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
+    extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:97
+    // tests/artifacts/PrimitiveOps/contract.py:247
     // @arc4.abimethod()
-    callsub verify_uint64_ge
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_biguint_xor_uint64
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_init_route@21:
-    // tests/artifacts/PrimitiveOps/contract.py:102
+main_verify_biguint_xor_route@44:
+    // tests/artifacts/PrimitiveOps/contract.py:240
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:102
+    extract 2 0
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:240
     // @arc4.abimethod()
-    callsub verify_bytes_init
+    callsub verify_biguint_xor
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_add_route@22:
-    // tests/artifacts/PrimitiveOps/contract.py:107
+main_verify_biguint_or_uint64_route@43:
+    // tests/artifacts/PrimitiveOps/contract.py:234
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
-    extract 2 0
-    txna ApplicationArgs 3
-    btoi
-    txna ApplicationArgs 4
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:107
+    // tests/artifacts/PrimitiveOps/contract.py:234
     // @arc4.abimethod()
-    callsub verify_bytes_add
+    callsub verify_biguint_or_uint64
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_eq_route@23:
-    // tests/artifacts/PrimitiveOps/contract.py:117
+main_verify_biguint_or_route@42:
+    // tests/artifacts/PrimitiveOps/contract.py:227
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:117
+    // tests/artifacts/PrimitiveOps/contract.py:227
     // @arc4.abimethod()
-    callsub verify_bytes_eq
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_biguint_or
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_ne_route@24:
-    // tests/artifacts/PrimitiveOps/contract.py:122
+main_verify_biguint_and_uint64_route@41:
+    // tests/artifacts/PrimitiveOps/contract.py:221
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:122
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:221
     // @arc4.abimethod()
-    callsub verify_bytes_ne
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_biguint_and_uint64
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_and_route@25:
-    // tests/artifacts/PrimitiveOps/contract.py:127
+main_verify_biguint_and_route@40:
+    // tests/artifacts/PrimitiveOps/contract.py:214
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:127
+    // tests/artifacts/PrimitiveOps/contract.py:214
     // @arc4.abimethod()
-    callsub verify_bytes_and
+    callsub verify_biguint_and
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_or_route@26:
-    // tests/artifacts/PrimitiveOps/contract.py:132
+main_verify_biguint_mod_uint64_route@39:
+    // tests/artifacts/PrimitiveOps/contract.py:208
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:132
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:208
     // @arc4.abimethod()
-    callsub verify_bytes_or
+    callsub verify_biguint_mod_uint64
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_xor_route@27:
-    // tests/artifacts/PrimitiveOps/contract.py:137
+main_verify_biguint_mod_route@38:
+    // tests/artifacts/PrimitiveOps/contract.py:201
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:137
+    // tests/artifacts/PrimitiveOps/contract.py:201
     // @arc4.abimethod()
-    callsub verify_bytes_xor
+    callsub verify_biguint_mod
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_bytes_not_route@28:
-    // tests/artifacts/PrimitiveOps/contract.py:142
+main_verify_biguint_div_uint64_route@37:
+    // tests/artifacts/PrimitiveOps/contract.py:195
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:142
+    // tests/artifacts/PrimitiveOps/contract.py:195
     // @arc4.abimethod()
-    callsub verify_bytes_not
+    callsub verify_biguint_div_uint64
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_add_route@29:
-    // tests/artifacts/PrimitiveOps/contract.py:149
+main_verify_biguint_div_route@36:
+    // tests/artifacts/PrimitiveOps/contract.py:188
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:149
+    // tests/artifacts/PrimitiveOps/contract.py:188
     // @arc4.abimethod()
-    callsub verify_biguint_add
+    callsub verify_biguint_div
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_add_uint64_route@30:
-    // tests/artifacts/PrimitiveOps/contract.py:156
+main_verify_biguint_mul_uint64_route@35:
+    // tests/artifacts/PrimitiveOps/contract.py:182
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:156
+    // tests/artifacts/PrimitiveOps/contract.py:182
     // @arc4.abimethod()
-    callsub verify_biguint_add_uint64
+    callsub verify_biguint_mul_uint64
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_sub_route@31:
-    // tests/artifacts/PrimitiveOps/contract.py:162
+main_verify_biguint_mul_route@34:
+    // tests/artifacts/PrimitiveOps/contract.py:175
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:162
+    // tests/artifacts/PrimitiveOps/contract.py:175
     // @arc4.abimethod()
-    callsub verify_biguint_sub
+    callsub verify_biguint_mul
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_sub_uint64_route@32:
+main_verify_biguint_sub_uint64_route@33:
     // tests/artifacts/PrimitiveOps/contract.py:169
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
@@ -909,869 +888,839 @@ main_verify_biguint_sub_uint64_route@32:
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_mul_route@33:
-    // tests/artifacts/PrimitiveOps/contract.py:175
+main_verify_biguint_sub_route@32:
+    // tests/artifacts/PrimitiveOps/contract.py:162
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:175
+    // tests/artifacts/PrimitiveOps/contract.py:162
     // @arc4.abimethod()
-    callsub verify_biguint_mul
+    callsub verify_biguint_sub
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_mul_uint64_route@34:
-    // tests/artifacts/PrimitiveOps/contract.py:182
+main_verify_biguint_add_uint64_route@31:
+    // tests/artifacts/PrimitiveOps/contract.py:156
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:182
+    // tests/artifacts/PrimitiveOps/contract.py:156
     // @arc4.abimethod()
-    callsub verify_biguint_mul_uint64
+    callsub verify_biguint_add_uint64
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_div_route@35:
-    // tests/artifacts/PrimitiveOps/contract.py:188
+main_verify_biguint_add_route@30:
+    // tests/artifacts/PrimitiveOps/contract.py:149
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:188
+    // tests/artifacts/PrimitiveOps/contract.py:149
     // @arc4.abimethod()
-    callsub verify_biguint_div
+    callsub verify_biguint_add
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_div_uint64_route@36:
-    // tests/artifacts/PrimitiveOps/contract.py:195
+main_verify_bytes_not_route@29:
+    // tests/artifacts/PrimitiveOps/contract.py:142
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:195
+    // tests/artifacts/PrimitiveOps/contract.py:142
     // @arc4.abimethod()
-    callsub verify_biguint_div_uint64
+    callsub verify_bytes_not
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_mod_route@37:
-    // tests/artifacts/PrimitiveOps/contract.py:201
+main_verify_bytes_xor_route@28:
+    // tests/artifacts/PrimitiveOps/contract.py:137
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:201
+    // tests/artifacts/PrimitiveOps/contract.py:137
     // @arc4.abimethod()
-    callsub verify_biguint_mod
+    callsub verify_bytes_xor
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_mod_uint64_route@38:
-    // tests/artifacts/PrimitiveOps/contract.py:208
+main_verify_bytes_or_route@27:
+    // tests/artifacts/PrimitiveOps/contract.py:132
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:208
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:132
     // @arc4.abimethod()
-    callsub verify_biguint_mod_uint64
+    callsub verify_bytes_or
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_and_route@39:
-    // tests/artifacts/PrimitiveOps/contract.py:214
+main_verify_bytes_and_route@26:
+    // tests/artifacts/PrimitiveOps/contract.py:127
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:214
+    // tests/artifacts/PrimitiveOps/contract.py:127
     // @arc4.abimethod()
-    callsub verify_biguint_and
+    callsub verify_bytes_and
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_and_uint64_route@40:
-    // tests/artifacts/PrimitiveOps/contract.py:221
+main_verify_bytes_ne_route@25:
+    // tests/artifacts/PrimitiveOps/contract.py:122
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/PrimitiveOps/contract.py:221
+    extract 2 0
+    // tests/artifacts/PrimitiveOps/contract.py:122
     // @arc4.abimethod()
-    callsub verify_biguint_and_uint64
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_bytes_ne
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_or_route@41:
-    // tests/artifacts/PrimitiveOps/contract.py:227
+main_verify_bytes_eq_route@24:
+    // tests/artifacts/PrimitiveOps/contract.py:117
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:227
+    // tests/artifacts/PrimitiveOps/contract.py:117
     // @arc4.abimethod()
-    callsub verify_biguint_or
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_bytes_eq
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_or_uint64_route@42:
-    // tests/artifacts/PrimitiveOps/contract.py:234
+main_verify_bytes_add_route@23:
+    // tests/artifacts/PrimitiveOps/contract.py:107
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
     txna ApplicationArgs 2
+    extract 2 0
+    txna ApplicationArgs 3
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:234
+    txna ApplicationArgs 4
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:107
     // @arc4.abimethod()
-    callsub verify_biguint_or_uint64
+    callsub verify_bytes_add
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_xor_route@43:
-    // tests/artifacts/PrimitiveOps/contract.py:240
+main_verify_bytes_init_route@22:
+    // tests/artifacts/PrimitiveOps/contract.py:102
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
-    txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:240
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:102
     // @arc4.abimethod()
-    callsub verify_biguint_xor
+    callsub verify_bytes_init
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_xor_uint64_route@44:
-    // tests/artifacts/PrimitiveOps/contract.py:247
+main_verify_uint64_ge_route@21:
+    // tests/artifacts/PrimitiveOps/contract.py:97
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:247
+    // tests/artifacts/PrimitiveOps/contract.py:97
     // @arc4.abimethod()
-    callsub verify_biguint_xor_uint64
-    dup
-    len
-    itob
-    extract 6 2
+    callsub verify_uint64_ge
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
-    byte 0x151f7c75
+    log
+    intc_0 // 1
+    return
+
+main_verify_uint64_gt_route@20:
+    // tests/artifacts/PrimitiveOps/contract.py:92
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    // tests/artifacts/PrimitiveOps/contract.py:6
+    // class PrimitiveOpsContract(ARC4Contract):
+    txna ApplicationArgs 1
+    btoi
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:92
+    // @arc4.abimethod()
+    callsub verify_uint64_gt
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_eq_route@45:
-    // tests/artifacts/PrimitiveOps/contract.py:253
+main_verify_uint64_le_route@19:
+    // tests/artifacts/PrimitiveOps/contract.py:87
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:253
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:87
     // @arc4.abimethod()
-    callsub verify_biguint_eq
-    byte 0x00
-    int 0
+    callsub verify_uint64_le
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_eq_uint64_route@46:
-    // tests/artifacts/PrimitiveOps/contract.py:260
+main_verify_uint64_lt_route@18:
+    // tests/artifacts/PrimitiveOps/contract.py:82
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:260
+    // tests/artifacts/PrimitiveOps/contract.py:82
     // @arc4.abimethod()
-    callsub verify_biguint_eq_uint64
-    byte 0x00
-    int 0
+    callsub verify_uint64_lt
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_ne_route@47:
-    // tests/artifacts/PrimitiveOps/contract.py:266
+main_verify_uint64_ne_route@17:
+    // tests/artifacts/PrimitiveOps/contract.py:77
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:266
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:77
     // @arc4.abimethod()
-    callsub verify_biguint_ne
-    byte 0x00
-    int 0
+    callsub verify_uint64_ne
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_ne_uint64_route@48:
-    // tests/artifacts/PrimitiveOps/contract.py:273
+main_verify_uint64_eq_route@16:
+    // tests/artifacts/PrimitiveOps/contract.py:72
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:273
+    // tests/artifacts/PrimitiveOps/contract.py:72
     // @arc4.abimethod()
-    callsub verify_biguint_ne_uint64
-    byte 0x00
-    int 0
+    callsub verify_uint64_eq
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 2
     setbit
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_lt_route@49:
-    // tests/artifacts/PrimitiveOps/contract.py:279
+main_verify_uint64_pow_route@15:
+    // tests/artifacts/PrimitiveOps/contract.py:67
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:279
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:67
     // @arc4.abimethod()
-    callsub verify_biguint_lt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_pow
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_lt_uint64_route@50:
-    // tests/artifacts/PrimitiveOps/contract.py:286
+main_verify_uint64_rshift_route@14:
+    // tests/artifacts/PrimitiveOps/contract.py:62
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:286
+    // tests/artifacts/PrimitiveOps/contract.py:62
     // @arc4.abimethod()
-    callsub verify_biguint_lt_uint64
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_rshift
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_le_route@51:
-    // tests/artifacts/PrimitiveOps/contract.py:292
+main_verify_uint64_lshift_route@13:
+    // tests/artifacts/PrimitiveOps/contract.py:57
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:292
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:57
     // @arc4.abimethod()
-    callsub verify_biguint_le
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_lshift
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_le_uint64_route@52:
-    // tests/artifacts/PrimitiveOps/contract.py:299
+main_verify_uint64_not_route@12:
+    // tests/artifacts/PrimitiveOps/contract.py:52
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
-    txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:299
+    // tests/artifacts/PrimitiveOps/contract.py:52
     // @arc4.abimethod()
-    callsub verify_biguint_le_uint64
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_not
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_gt_route@53:
-    // tests/artifacts/PrimitiveOps/contract.py:305
+main_verify_uint64_xor_route@11:
+    // tests/artifacts/PrimitiveOps/contract.py:47
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:305
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:47
     // @arc4.abimethod()
-    callsub verify_biguint_gt
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_xor
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_gt_uint64_route@54:
-    // tests/artifacts/PrimitiveOps/contract.py:312
+main_verify_uint64_or_route@10:
+    // tests/artifacts/PrimitiveOps/contract.py:42
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:312
+    // tests/artifacts/PrimitiveOps/contract.py:42
     // @arc4.abimethod()
-    callsub verify_biguint_gt_uint64
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_or
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_ge_route@55:
-    // tests/artifacts/PrimitiveOps/contract.py:318
+main_verify_uint64_and_route@9:
+    // tests/artifacts/PrimitiveOps/contract.py:37
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:318
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:37
     // @arc4.abimethod()
-    callsub verify_biguint_ge
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_and
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_biguint_ge_uint64_route@56:
-    // tests/artifacts/PrimitiveOps/contract.py:325
+main_verify_uint64_mod_route@8:
+    // tests/artifacts/PrimitiveOps/contract.py:32
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
     btoi
-    // tests/artifacts/PrimitiveOps/contract.py:325
+    // tests/artifacts/PrimitiveOps/contract.py:32
     // @arc4.abimethod()
-    callsub verify_biguint_ge_uint64
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_uint64_mod
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_init_route@57:
-    // tests/artifacts/PrimitiveOps/contract.py:331
-    // @arc4.abimethod
+main_verify_uint64_div_route@7:
+    // tests/artifacts/PrimitiveOps/contract.py:27
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:331
-    // @arc4.abimethod
-    callsub verify_string_init
-    dup
-    len
+    btoi
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:27
+    // @arc4.abimethod()
+    callsub verify_uint64_div
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_startswith_route@58:
-    // tests/artifacts/PrimitiveOps/contract.py:336
-    // @arc4.abimethod
+main_verify_uint64_mul_route@6:
+    // tests/artifacts/PrimitiveOps/contract.py:22
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:336
-    // @arc4.abimethod
-    callsub verify_string_startswith
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:22
+    // @arc4.abimethod()
+    callsub verify_uint64_mul
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_endswith_route@59:
-    // tests/artifacts/PrimitiveOps/contract.py:341
-    // @arc4.abimethod
+main_verify_uint64_sub_route@5:
+    // tests/artifacts/PrimitiveOps/contract.py:17
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:341
-    // @arc4.abimethod
-    callsub verify_string_endswith
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:17
+    // @arc4.abimethod()
+    callsub verify_uint64_sub
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_string_join_route@60:
-    // tests/artifacts/PrimitiveOps/contract.py:346
-    // @arc4.abimethod
+main_verify_uint64_add_route@4:
+    // tests/artifacts/PrimitiveOps/contract.py:12
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
-    extract 2 0
+    btoi
     txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:346
-    // @arc4.abimethod
-    callsub verify_string_join
-    dup
-    len
+    btoi
+    // tests/artifacts/PrimitiveOps/contract.py:12
+    // @arc4.abimethod()
+    callsub verify_uint64_add
     itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_log_route@61:
-    // tests/artifacts/PrimitiveOps/contract.py:351
-    // @arc4.abimethod
+main_verify_uint64_init_route@3:
+    // tests/artifacts/PrimitiveOps/contract.py:7
+    // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
-    txna ApplicationArgs 2
-    btoi
-    txna ApplicationArgs 3
-    extract 2 0
-    txna ApplicationArgs 4
-    extract 2 0
-    txna ApplicationArgs 5
-    txna ApplicationArgs 6
-    txna ApplicationArgs 7
-    txna ApplicationArgs 8
-    txna ApplicationArgs 9
-    txna ApplicationArgs 10
-    txna ApplicationArgs 11
-    extract 2 0
-    txna ApplicationArgs 12
-    extract 2 0
-    txna ApplicationArgs 13
-    extract 2 0
-    // tests/artifacts/PrimitiveOps/contract.py:351
-    // @arc4.abimethod
-    callsub verify_log
-    int 1
+    // tests/artifacts/PrimitiveOps/contract.py:7
+    // @arc4.abimethod()
+    callsub verify_uint64_init
+    itob
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_bare_routing@64:
+main_bare_routing@65:
     // tests/artifacts/PrimitiveOps/contract.py:6
     // class PrimitiveOpsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@69
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
@@ -2705,7 +2654,7 @@ verify_string_init:
     proto 1 1
     // tests/artifacts/PrimitiveOps/contract.py:333
     // result = String("Hello, ") + a
-    byte "Hello, "
+    pushbytes "Hello, "
     frame_dig -1
     concat
     // tests/artifacts/PrimitiveOps/contract.py:334
@@ -2728,24 +2677,24 @@ verify_string_startswith:
     len
     >
     bz verify_string_startswith_ternary_false@2
-    int 0
-    b verify_string_startswith_ternary_merge@3
+    intc_1 // 0
+
+verify_string_startswith_ternary_merge@3:
+    // tests/artifacts/PrimitiveOps/contract.py:339
+    // return result
+    swap
+    retsub
 
 verify_string_startswith_ternary_false@2:
     // tests/artifacts/PrimitiveOps/contract.py:338
     // result = a.startswith(b)
     frame_dig -2
-    int 0
+    intc_1 // 0
     frame_dig 0
     extract3
     frame_dig -1
     ==
-
-verify_string_startswith_ternary_merge@3:
-    // tests/artifacts/PrimitiveOps/contract.py:339
-    // return result
-    swap
-    retsub
+    b verify_string_startswith_ternary_merge@3
 
 
 // tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_endswith(a: bytes, b: bytes) -> uint64:
@@ -2765,8 +2714,13 @@ verify_string_endswith:
     cover 2
     >
     bz verify_string_endswith_ternary_false@2
-    int 0
-    b verify_string_endswith_ternary_merge@3
+    intc_1 // 0
+
+verify_string_endswith_ternary_merge@3:
+    // tests/artifacts/PrimitiveOps/contract.py:344
+    // return result
+    frame_bury 0
+    retsub
 
 verify_string_endswith_ternary_false@2:
     // tests/artifacts/PrimitiveOps/contract.py:343
@@ -2782,12 +2736,7 @@ verify_string_endswith_ternary_false@2:
     extract3
     frame_dig -1
     ==
-
-verify_string_endswith_ternary_merge@3:
-    // tests/artifacts/PrimitiveOps/contract.py:344
-    // return result
-    frame_bury 0
-    retsub
+    b verify_string_endswith_ternary_merge@3
 
 
 // tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_join(a: bytes, b: bytes) -> bytes:
@@ -2799,7 +2748,7 @@ verify_string_join:
     // tests/artifacts/PrimitiveOps/contract.py:348
     // result = String(", ").join((a, b))
     frame_dig -2
-    byte ", "
+    pushbytes ", "
     concat
     frame_dig -1
     concat
@@ -2832,52 +2781,52 @@ verify_log:
     // tests/artifacts/PrimitiveOps/contract.py:372
     // log(a, b, c, d_biguint, e, f, g, h, i, j, arc4_k, arc4_m, arc4_n, sep="-")
     frame_dig -13
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -12
     itob
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -11
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -10
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -9
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -8
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -7
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -6
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -5
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -4
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -3
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -2
     concat
-    byte "-"
+    bytec_2 // "-"
     concat
     frame_dig -1
     concat
diff --git a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc32.json b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc32.json
index 0a9d7e5..0d3b69d 100644
--- a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc32.json
+++ b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.arc32.json
@@ -302,8 +302,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.approval_program:
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@64
    method "verify_uint64_init(byte[])uint64"
    method "verify_uint64_add(uint64,uint64)uint64"
    method "verify_uint64_sub(uint64,uint64)uint64"
    method "verify_uint64_mul(uint64,uint64)uint64"
    method "verify_uint64_div(uint64,uint64)uint64"
    method "verify_uint64_mod(uint64,uint64)uint64"
    method "verify_uint64_and(uint64,uint64)uint64"
    method "verify_uint64_or(uint64,uint64)uint64"
    method "verify_uint64_xor(uint64,uint64)uint64"
    method "verify_uint64_not(uint64)uint64"
    method "verify_uint64_lshift(uint64,uint64)uint64"
    method "verify_uint64_rshift(uint64,uint64)uint64"
    method "verify_uint64_pow(uint64,uint64)uint64"
    method "verify_uint64_eq(uint64,uint64)bool"
    method "verify_uint64_ne(uint64,uint64)bool"
    method "verify_uint64_lt(uint64,uint64)bool"
    method "verify_uint64_le(uint64,uint64)bool"
    method "verify_uint64_gt(uint64,uint64)bool"
    method "verify_uint64_ge(uint64,uint64)bool"
    method "verify_bytes_init(uint64)byte[]"
    method "verify_bytes_add(byte[],byte[],uint64,uint64)byte[]"
    method "verify_bytes_eq(byte[],byte[])bool"
    method "verify_bytes_ne(byte[],byte[])bool"
    method "verify_bytes_and(byte[],byte[])byte[]"
    method "verify_bytes_or(byte[],byte[])byte[]"
    method "verify_bytes_xor(byte[],byte[])byte[]"
    method "verify_bytes_not(byte[],uint64)byte[]"
    method "verify_biguint_add(byte[],byte[])byte[]"
    method "verify_biguint_add_uint64(byte[],uint64)byte[]"
    method "verify_biguint_sub(byte[],byte[])byte[]"
    method "verify_biguint_sub_uint64(byte[],uint64)byte[]"
    method "verify_biguint_mul(byte[],byte[])byte[]"
    method "verify_biguint_mul_uint64(byte[],uint64)byte[]"
    method "verify_biguint_div(byte[],byte[])byte[]"
    method "verify_biguint_div_uint64(byte[],uint64)byte[]"
    method "verify_biguint_mod(byte[],byte[])byte[]"
    method "verify_biguint_mod_uint64(byte[],uint64)byte[]"
    method "verify_biguint_and(byte[],byte[])byte[]"
    method "verify_biguint_and_uint64(byte[],uint64)byte[]"
    method "verify_biguint_or(byte[],byte[])byte[]"
    method "verify_biguint_or_uint64(byte[],uint64)byte[]"
    method "verify_biguint_xor(byte[],byte[])byte[]"
    method "verify_biguint_xor_uint64(byte[],uint64)byte[]"
    method "verify_biguint_eq(byte[],byte[])bool"
    method "verify_biguint_eq_uint64(byte[],uint64)bool"
    method "verify_biguint_ne(byte[],byte[])bool"
    method "verify_biguint_ne_uint64(byte[],uint64)bool"
    method "verify_biguint_lt(byte[],byte[])bool"
    method "verify_biguint_lt_uint64(byte[],uint64)bool"
    method "verify_biguint_le(byte[],byte[])bool"
    method "verify_biguint_le_uint64(byte[],uint64)bool"
    method "verify_biguint_gt(byte[],byte[])bool"
    method "verify_biguint_gt_uint64(byte[],uint64)bool"
    method "verify_biguint_ge(byte[],byte[])bool"
    method "verify_biguint_ge_uint64(byte[],uint64)bool"
    method "verify_string_init(string)string"
    method "verify_string_startswith(string,string)bool"
    method "verify_string_endswith(string,string)bool"
    method "verify_string_join(string,string)string"
    method "verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_uint64_init_route@2 main_verify_uint64_add_route@3 main_verify_uint64_sub_route@4 main_verify_uint64_mul_route@5 main_verify_uint64_div_route@6 main_verify_uint64_mod_route@7 main_verify_uint64_and_route@8 main_verify_uint64_or_route@9 main_verify_uint64_xor_route@10 main_verify_uint64_not_route@11 main_verify_uint64_lshift_route@12 main_verify_uint64_rshift_route@13 main_verify_uint64_pow_route@14 main_verify_uint64_eq_route@15 main_verify_uint64_ne_route@16 main_verify_uint64_lt_route@17 main_verify_uint64_le_route@18 main_verify_uint64_gt_route@19 main_verify_uint64_ge_route@20 main_verify_bytes_init_route@21 main_verify_bytes_add_route@22 main_verify_bytes_eq_route@23 main_verify_bytes_ne_route@24 main_verify_bytes_and_route@25 main_verify_bytes_or_route@26 main_verify_bytes_xor_route@27 main_verify_bytes_not_route@28 main_verify_biguint_add_route@29 main_verify_biguint_add_uint64_route@30 main_verify_biguint_sub_route@31 main_verify_biguint_sub_uint64_route@32 main_verify_biguint_mul_route@33 main_verify_biguint_mul_uint64_route@34 main_verify_biguint_div_route@35 main_verify_biguint_div_uint64_route@36 main_verify_biguint_mod_route@37 main_verify_biguint_mod_uint64_route@38 main_verify_biguint_and_route@39 main_verify_biguint_and_uint64_route@40 main_verify_biguint_or_route@41 main_verify_biguint_or_uint64_route@42 main_verify_biguint_xor_route@43 main_verify_biguint_xor_uint64_route@44 main_verify_biguint_eq_route@45 main_verify_biguint_eq_uint64_route@46 main_verify_biguint_ne_route@47 main_verify_biguint_ne_uint64_route@48 main_verify_biguint_lt_route@49 main_verify_biguint_lt_uint64_route@50 main_verify_biguint_le_route@51 main_verify_biguint_le_uint64_route@52 main_verify_biguint_gt_route@53 main_verify_biguint_gt_uint64_route@54 main_verify_biguint_ge_route@55 main_verify_biguint_ge_uint64_route@56 main_verify_string_init_route@57 main_verify_string_startswith_route@58 main_verify_string_endswith_route@59 main_verify_string_join_route@60 main_verify_log_route@61
    err // reject transaction

main_verify_uint64_init_route@2:
    // tests/artifacts/PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    callsub verify_uint64_init
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_add_route@3:
    // tests/artifacts/PrimitiveOps/contract.py:12
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:12
    // @arc4.abimethod()
    callsub verify_uint64_add
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_sub_route@4:
    // tests/artifacts/PrimitiveOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:17
    // @arc4.abimethod()
    callsub verify_uint64_sub
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_mul_route@5:
    // tests/artifacts/PrimitiveOps/contract.py:22
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:22
    // @arc4.abimethod()
    callsub verify_uint64_mul
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_div_route@6:
    // tests/artifacts/PrimitiveOps/contract.py:27
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:27
    // @arc4.abimethod()
    callsub verify_uint64_div
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_mod_route@7:
    // tests/artifacts/PrimitiveOps/contract.py:32
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:32
    // @arc4.abimethod()
    callsub verify_uint64_mod
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_and_route@8:
    // tests/artifacts/PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_uint64_and
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_or_route@9:
    // tests/artifacts/PrimitiveOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:42
    // @arc4.abimethod()
    callsub verify_uint64_or
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_xor_route@10:
    // tests/artifacts/PrimitiveOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_uint64_xor
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_not_route@11:
    // tests/artifacts/PrimitiveOps/contract.py:52
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:52
    // @arc4.abimethod()
    callsub verify_uint64_not
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_lshift_route@12:
    // tests/artifacts/PrimitiveOps/contract.py:57
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:57
    // @arc4.abimethod()
    callsub verify_uint64_lshift
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_rshift_route@13:
    // tests/artifacts/PrimitiveOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:62
    // @arc4.abimethod()
    callsub verify_uint64_rshift
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_pow_route@14:
    // tests/artifacts/PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_uint64_pow
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_eq_route@15:
    // tests/artifacts/PrimitiveOps/contract.py:72
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:72
    // @arc4.abimethod()
    callsub verify_uint64_eq
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_ne_route@16:
    // tests/artifacts/PrimitiveOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_uint64_ne
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_lt_route@17:
    // tests/artifacts/PrimitiveOps/contract.py:82
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:82
    // @arc4.abimethod()
    callsub verify_uint64_lt
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_le_route@18:
    // tests/artifacts/PrimitiveOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_uint64_le
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_gt_route@19:
    // tests/artifacts/PrimitiveOps/contract.py:92
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:92
    // @arc4.abimethod()
    callsub verify_uint64_gt
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_uint64_ge_route@20:
    // tests/artifacts/PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    callsub verify_uint64_ge
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_init_route@21:
    // tests/artifacts/PrimitiveOps/contract.py:102
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:102
    // @arc4.abimethod()
    callsub verify_bytes_init
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_add_route@22:
    // tests/artifacts/PrimitiveOps/contract.py:107
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:107
    // @arc4.abimethod()
    callsub verify_bytes_add
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_eq_route@23:
    // tests/artifacts/PrimitiveOps/contract.py:117
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:117
    // @arc4.abimethod()
    callsub verify_bytes_eq
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_ne_route@24:
    // tests/artifacts/PrimitiveOps/contract.py:122
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:122
    // @arc4.abimethod()
    callsub verify_bytes_ne
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_and_route@25:
    // tests/artifacts/PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    callsub verify_bytes_and
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_or_route@26:
    // tests/artifacts/PrimitiveOps/contract.py:132
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:132
    // @arc4.abimethod()
    callsub verify_bytes_or
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_xor_route@27:
    // tests/artifacts/PrimitiveOps/contract.py:137
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:137
    // @arc4.abimethod()
    callsub verify_bytes_xor
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_bytes_not_route@28:
    // tests/artifacts/PrimitiveOps/contract.py:142
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:142
    // @arc4.abimethod()
    callsub verify_bytes_not
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_add_route@29:
    // tests/artifacts/PrimitiveOps/contract.py:149
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:149
    // @arc4.abimethod()
    callsub verify_biguint_add
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_add_uint64_route@30:
    // tests/artifacts/PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_biguint_add_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_sub_route@31:
    // tests/artifacts/PrimitiveOps/contract.py:162
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:162
    // @arc4.abimethod()
    callsub verify_biguint_sub
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_sub_uint64_route@32:
    // tests/artifacts/PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:169
    // @arc4.abimethod()
    callsub verify_biguint_sub_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_mul_route@33:
    // tests/artifacts/PrimitiveOps/contract.py:175
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:175
    // @arc4.abimethod()
    callsub verify_biguint_mul
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_mul_uint64_route@34:
    // tests/artifacts/PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    callsub verify_biguint_mul_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_div_route@35:
    // tests/artifacts/PrimitiveOps/contract.py:188
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:188
    // @arc4.abimethod()
    callsub verify_biguint_div
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_div_uint64_route@36:
    // tests/artifacts/PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    callsub verify_biguint_div_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_mod_route@37:
    // tests/artifacts/PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    callsub verify_biguint_mod
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_mod_uint64_route@38:
    // tests/artifacts/PrimitiveOps/contract.py:208
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:208
    // @arc4.abimethod()
    callsub verify_biguint_mod_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_and_route@39:
    // tests/artifacts/PrimitiveOps/contract.py:214
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:214
    // @arc4.abimethod()
    callsub verify_biguint_and
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_and_uint64_route@40:
    // tests/artifacts/PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    callsub verify_biguint_and_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_or_route@41:
    // tests/artifacts/PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:227
    // @arc4.abimethod()
    callsub verify_biguint_or
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_or_uint64_route@42:
    // tests/artifacts/PrimitiveOps/contract.py:234
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:234
    // @arc4.abimethod()
    callsub verify_biguint_or_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_xor_route@43:
    // tests/artifacts/PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:240
    // @arc4.abimethod()
    callsub verify_biguint_xor
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_xor_uint64_route@44:
    // tests/artifacts/PrimitiveOps/contract.py:247
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:247
    // @arc4.abimethod()
    callsub verify_biguint_xor_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_eq_route@45:
    // tests/artifacts/PrimitiveOps/contract.py:253
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:253
    // @arc4.abimethod()
    callsub verify_biguint_eq
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_eq_uint64_route@46:
    // tests/artifacts/PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    callsub verify_biguint_eq_uint64
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_ne_route@47:
    // tests/artifacts/PrimitiveOps/contract.py:266
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:266
    // @arc4.abimethod()
    callsub verify_biguint_ne
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_ne_uint64_route@48:
    // tests/artifacts/PrimitiveOps/contract.py:273
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:273
    // @arc4.abimethod()
    callsub verify_biguint_ne_uint64
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_lt_route@49:
    // tests/artifacts/PrimitiveOps/contract.py:279
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:279
    // @arc4.abimethod()
    callsub verify_biguint_lt
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_lt_uint64_route@50:
    // tests/artifacts/PrimitiveOps/contract.py:286
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:286
    // @arc4.abimethod()
    callsub verify_biguint_lt_uint64
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_le_route@51:
    // tests/artifacts/PrimitiveOps/contract.py:292
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:292
    // @arc4.abimethod()
    callsub verify_biguint_le
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_le_uint64_route@52:
    // tests/artifacts/PrimitiveOps/contract.py:299
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:299
    // @arc4.abimethod()
    callsub verify_biguint_le_uint64
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_gt_route@53:
    // tests/artifacts/PrimitiveOps/contract.py:305
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:305
    // @arc4.abimethod()
    callsub verify_biguint_gt
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_gt_uint64_route@54:
    // tests/artifacts/PrimitiveOps/contract.py:312
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:312
    // @arc4.abimethod()
    callsub verify_biguint_gt_uint64
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_ge_route@55:
    // tests/artifacts/PrimitiveOps/contract.py:318
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:318
    // @arc4.abimethod()
    callsub verify_biguint_ge
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_biguint_ge_uint64_route@56:
    // tests/artifacts/PrimitiveOps/contract.py:325
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:325
    // @arc4.abimethod()
    callsub verify_biguint_ge_uint64
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_init_route@57:
    // tests/artifacts/PrimitiveOps/contract.py:331
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:331
    // @arc4.abimethod
    callsub verify_string_init
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_startswith_route@58:
    // tests/artifacts/PrimitiveOps/contract.py:336
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:336
    // @arc4.abimethod
    callsub verify_string_startswith
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_endswith_route@59:
    // tests/artifacts/PrimitiveOps/contract.py:341
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:341
    // @arc4.abimethod
    callsub verify_string_endswith
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_string_join_route@60:
    // tests/artifacts/PrimitiveOps/contract.py:346
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:346
    // @arc4.abimethod
    callsub verify_string_join
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_log_route@61:
    // tests/artifacts/PrimitiveOps/contract.py:351
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    extract 2 0
    txna ApplicationArgs 12
    extract 2 0
    txna ApplicationArgs 13
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:351
    // @arc4.abimethod
    callsub verify_log
    int 1
    return

main_bare_routing@64:
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_init(raw_value: bytes) -> uint64:
verify_uint64_init:
    // tests/artifacts/PrimitiveOps/contract.py:7-8
    // @arc4.abimethod()
    // def verify_uint64_init(self, raw_value: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:9
    // result = op.btoi(raw_value)
    frame_dig -1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:10
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_add(a: uint64, b: uint64) -> uint64:
verify_uint64_add:
    // tests/artifacts/PrimitiveOps/contract.py:12-13
    // @arc4.abimethod()
    // def verify_uint64_add(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:14
    // result = a + b
    frame_dig -2
    frame_dig -1
    +
    // tests/artifacts/PrimitiveOps/contract.py:15
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_sub(a: uint64, b: uint64) -> uint64:
verify_uint64_sub:
    // tests/artifacts/PrimitiveOps/contract.py:17-18
    // @arc4.abimethod()
    // def verify_uint64_sub(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:19
    // result = a - b
    frame_dig -2
    frame_dig -1
    -
    // tests/artifacts/PrimitiveOps/contract.py:20
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_mul(a: uint64, b: uint64) -> uint64:
verify_uint64_mul:
    // tests/artifacts/PrimitiveOps/contract.py:22-23
    // @arc4.abimethod()
    // def verify_uint64_mul(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:24
    // result = a * b
    frame_dig -2
    frame_dig -1
    *
    // tests/artifacts/PrimitiveOps/contract.py:25
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_div(a: uint64, b: uint64) -> uint64:
verify_uint64_div:
    // tests/artifacts/PrimitiveOps/contract.py:27-28
    // @arc4.abimethod()
    // def verify_uint64_div(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:29
    // result = a // b
    frame_dig -2
    frame_dig -1
    /
    // tests/artifacts/PrimitiveOps/contract.py:30
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_mod(a: uint64, b: uint64) -> uint64:
verify_uint64_mod:
    // tests/artifacts/PrimitiveOps/contract.py:32-33
    // @arc4.abimethod()
    // def verify_uint64_mod(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:34
    // result = a % b
    frame_dig -2
    frame_dig -1
    %
    // tests/artifacts/PrimitiveOps/contract.py:35
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_and(a: uint64, b: uint64) -> uint64:
verify_uint64_and:
    // tests/artifacts/PrimitiveOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_uint64_and(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:39
    // result = a & b
    frame_dig -2
    frame_dig -1
    &
    // tests/artifacts/PrimitiveOps/contract.py:40
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_or(a: uint64, b: uint64) -> uint64:
verify_uint64_or:
    // tests/artifacts/PrimitiveOps/contract.py:42-43
    // @arc4.abimethod()
    // def verify_uint64_or(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:44
    // result = a | b
    frame_dig -2
    frame_dig -1
    |
    // tests/artifacts/PrimitiveOps/contract.py:45
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_xor(a: uint64, b: uint64) -> uint64:
verify_uint64_xor:
    // tests/artifacts/PrimitiveOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_uint64_xor(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:49
    // result = a ^ b
    frame_dig -2
    frame_dig -1
    ^
    // tests/artifacts/PrimitiveOps/contract.py:50
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_not(a: uint64) -> uint64:
verify_uint64_not:
    // tests/artifacts/PrimitiveOps/contract.py:52-53
    // @arc4.abimethod()
    // def verify_uint64_not(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:54
    // result = ~a
    frame_dig -1
    ~
    // tests/artifacts/PrimitiveOps/contract.py:55
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_lshift(a: uint64, b: uint64) -> uint64:
verify_uint64_lshift:
    // tests/artifacts/PrimitiveOps/contract.py:57-58
    // @arc4.abimethod()
    // def verify_uint64_lshift(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:59
    // result = a << b
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/PrimitiveOps/contract.py:60
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_rshift(a: uint64, b: uint64) -> uint64:
verify_uint64_rshift:
    // tests/artifacts/PrimitiveOps/contract.py:62-63
    // @arc4.abimethod()
    // def verify_uint64_rshift(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:64
    // result = a >> b
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/PrimitiveOps/contract.py:65
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_pow(a: uint64, b: uint64) -> uint64:
verify_uint64_pow:
    // tests/artifacts/PrimitiveOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_uint64_pow(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:69
    // result = a**b
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/PrimitiveOps/contract.py:70
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_eq(a: uint64, b: uint64) -> uint64:
verify_uint64_eq:
    // tests/artifacts/PrimitiveOps/contract.py:72-73
    // @arc4.abimethod()
    // def verify_uint64_eq(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:74
    // result = a == b
    frame_dig -2
    frame_dig -1
    ==
    // tests/artifacts/PrimitiveOps/contract.py:75
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_ne(a: uint64, b: uint64) -> uint64:
verify_uint64_ne:
    // tests/artifacts/PrimitiveOps/contract.py:77-78
    // @arc4.abimethod()
    // def verify_uint64_ne(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:79
    // result = a != b
    frame_dig -2
    frame_dig -1
    !=
    // tests/artifacts/PrimitiveOps/contract.py:80
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_lt(a: uint64, b: uint64) -> uint64:
verify_uint64_lt:
    // tests/artifacts/PrimitiveOps/contract.py:82-83
    // @arc4.abimethod()
    // def verify_uint64_lt(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:84
    // result = a < b
    frame_dig -2
    frame_dig -1
    <
    // tests/artifacts/PrimitiveOps/contract.py:85
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_le(a: uint64, b: uint64) -> uint64:
verify_uint64_le:
    // tests/artifacts/PrimitiveOps/contract.py:87-88
    // @arc4.abimethod()
    // def verify_uint64_le(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:89
    // result = a <= b
    frame_dig -2
    frame_dig -1
    <=
    // tests/artifacts/PrimitiveOps/contract.py:90
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_gt(a: uint64, b: uint64) -> uint64:
verify_uint64_gt:
    // tests/artifacts/PrimitiveOps/contract.py:92-93
    // @arc4.abimethod()
    // def verify_uint64_gt(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:94
    // result = a > b
    frame_dig -2
    frame_dig -1
    >
    // tests/artifacts/PrimitiveOps/contract.py:95
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_ge(a: uint64, b: uint64) -> uint64:
verify_uint64_ge:
    // tests/artifacts/PrimitiveOps/contract.py:97-98
    // @arc4.abimethod()
    // def verify_uint64_ge(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:99
    // result = a >= b
    frame_dig -2
    frame_dig -1
    >=
    // tests/artifacts/PrimitiveOps/contract.py:100
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_init(raw_value: uint64) -> bytes:
verify_bytes_init:
    // tests/artifacts/PrimitiveOps/contract.py:102-103
    // @arc4.abimethod()
    // def verify_bytes_init(self, raw_value: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:104
    // result = op.itob(raw_value)
    frame_dig -1
    itob
    // tests/artifacts/PrimitiveOps/contract.py:105
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_add(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_bytes_add:
    // tests/artifacts/PrimitiveOps/contract.py:107-110
    // @arc4.abimethod()
    // def verify_bytes_add(
    //     self, a: Bytes, b: Bytes, pad_a_size: UInt64, pad_b_size: UInt64
    // ) -> Bytes:
    proto 4 1
    // tests/artifacts/PrimitiveOps/contract.py:111
    // a = op.bzero(pad_a_size) + a
    frame_dig -2
    bzero
    frame_dig -4
    concat
    frame_bury -4
    // tests/artifacts/PrimitiveOps/contract.py:112
    // b = op.bzero(pad_b_size) + b
    frame_dig -1
    bzero
    frame_dig -3
    concat
    frame_bury -3
    // tests/artifacts/PrimitiveOps/contract.py:113
    // result = a + b
    frame_dig -4
    frame_dig -3
    concat
    // tests/artifacts/PrimitiveOps/contract.py:114
    // result = op.sha256(result)
    sha256
    // tests/artifacts/PrimitiveOps/contract.py:115
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_eq(a: bytes, b: bytes) -> uint64:
verify_bytes_eq:
    // tests/artifacts/PrimitiveOps/contract.py:117-118
    // @arc4.abimethod()
    // def verify_bytes_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:119
    // result = a == b
    frame_dig -2
    frame_dig -1
    ==
    // tests/artifacts/PrimitiveOps/contract.py:120
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_ne(a: bytes, b: bytes) -> uint64:
verify_bytes_ne:
    // tests/artifacts/PrimitiveOps/contract.py:122-123
    // @arc4.abimethod()
    // def verify_bytes_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:124
    // result = a != b
    frame_dig -2
    frame_dig -1
    !=
    // tests/artifacts/PrimitiveOps/contract.py:125
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_and(a: bytes, b: bytes) -> bytes:
verify_bytes_and:
    // tests/artifacts/PrimitiveOps/contract.py:127-128
    // @arc4.abimethod()
    // def verify_bytes_and(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:129
    // result = a & b
    frame_dig -2
    frame_dig -1
    b&
    // tests/artifacts/PrimitiveOps/contract.py:130
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_or(a: bytes, b: bytes) -> bytes:
verify_bytes_or:
    // tests/artifacts/PrimitiveOps/contract.py:132-133
    // @arc4.abimethod()
    // def verify_bytes_or(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:134
    // result = a | b
    frame_dig -2
    frame_dig -1
    b|
    // tests/artifacts/PrimitiveOps/contract.py:135
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_xor(a: bytes, b: bytes) -> bytes:
verify_bytes_xor:
    // tests/artifacts/PrimitiveOps/contract.py:137-138
    // @arc4.abimethod()
    // def verify_bytes_xor(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:139
    // result = a ^ b
    frame_dig -2
    frame_dig -1
    b^
    // tests/artifacts/PrimitiveOps/contract.py:140
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_not(a: bytes, pad_size: uint64) -> bytes:
verify_bytes_not:
    // tests/artifacts/PrimitiveOps/contract.py:142-143
    // @arc4.abimethod()
    // def verify_bytes_not(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:144
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/PrimitiveOps/contract.py:145
    // result = ~a
    b~
    // tests/artifacts/PrimitiveOps/contract.py:146
    // result = op.sha256(result)
    sha256
    // tests/artifacts/PrimitiveOps/contract.py:147
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_add(a: bytes, b: bytes) -> bytes:
verify_biguint_add:
    // tests/artifacts/PrimitiveOps/contract.py:149-150
    // @arc4.abimethod()
    // def verify_biguint_add(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:153
    // result = a_biguint + b_biguint
    frame_dig -2
    frame_dig -1
    b+
    // tests/artifacts/PrimitiveOps/contract.py:154
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_add_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_add_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_biguint_add_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:159
    // result = a_biguint + b
    frame_dig -1
    itob
    frame_dig -2
    b+
    // tests/artifacts/PrimitiveOps/contract.py:160
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_sub(a: bytes, b: bytes) -> bytes:
verify_biguint_sub:
    // tests/artifacts/PrimitiveOps/contract.py:162-163
    // @arc4.abimethod()
    // def verify_biguint_sub(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:166
    // result = a_biguint - b_biguint
    frame_dig -2
    frame_dig -1
    b-
    // tests/artifacts/PrimitiveOps/contract.py:167
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_sub_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_sub_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:169-170
    // @arc4.abimethod()
    // def verify_biguint_sub_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:172
    // result = a_biguint - b
    frame_dig -1
    itob
    frame_dig -2
    swap
    b-
    // tests/artifacts/PrimitiveOps/contract.py:173
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mul(a: bytes, b: bytes) -> bytes:
verify_biguint_mul:
    // tests/artifacts/PrimitiveOps/contract.py:175-176
    // @arc4.abimethod()
    // def verify_biguint_mul(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:179
    // result = a_biguint * b_biguint
    frame_dig -2
    frame_dig -1
    b*
    // tests/artifacts/PrimitiveOps/contract.py:180
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mul_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_mul_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:182-183
    // @arc4.abimethod()
    // def verify_biguint_mul_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:185
    // result = a_biguint * b
    frame_dig -1
    itob
    frame_dig -2
    b*
    // tests/artifacts/PrimitiveOps/contract.py:186
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_div(a: bytes, b: bytes) -> bytes:
verify_biguint_div:
    // tests/artifacts/PrimitiveOps/contract.py:188-189
    // @arc4.abimethod()
    // def verify_biguint_div(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:192
    // result = a_biguint // b_biguint
    frame_dig -2
    frame_dig -1
    b/
    // tests/artifacts/PrimitiveOps/contract.py:193
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_div_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_div_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:195-196
    // @arc4.abimethod()
    // def verify_biguint_div_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:198
    // result = a_biguint // b
    frame_dig -1
    itob
    frame_dig -2
    swap
    b/
    // tests/artifacts/PrimitiveOps/contract.py:199
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mod(a: bytes, b: bytes) -> bytes:
verify_biguint_mod:
    // tests/artifacts/PrimitiveOps/contract.py:201-202
    // @arc4.abimethod()
    // def verify_biguint_mod(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:205
    // result = a_biguint % b_biguint
    frame_dig -2
    frame_dig -1
    b%
    // tests/artifacts/PrimitiveOps/contract.py:206
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mod_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_mod_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:208-209
    // @arc4.abimethod()
    // def verify_biguint_mod_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:211
    // result = a_biguint % b
    frame_dig -1
    itob
    frame_dig -2
    swap
    b%
    // tests/artifacts/PrimitiveOps/contract.py:212
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_and(a: bytes, b: bytes) -> bytes:
verify_biguint_and:
    // tests/artifacts/PrimitiveOps/contract.py:214-215
    // @arc4.abimethod()
    // def verify_biguint_and(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:218
    // result = a_biguint & b_biguint
    frame_dig -2
    frame_dig -1
    b&
    // tests/artifacts/PrimitiveOps/contract.py:219
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_and_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_and_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:221-222
    // @arc4.abimethod()
    // def verify_biguint_and_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:224
    // result = a_biguint & b
    frame_dig -1
    itob
    frame_dig -2
    b&
    // tests/artifacts/PrimitiveOps/contract.py:225
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_or(a: bytes, b: bytes) -> bytes:
verify_biguint_or:
    // tests/artifacts/PrimitiveOps/contract.py:227-228
    // @arc4.abimethod()
    // def verify_biguint_or(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:231
    // result = a_biguint | b_biguint
    frame_dig -2
    frame_dig -1
    b|
    // tests/artifacts/PrimitiveOps/contract.py:232
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_or_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_or_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:234-235
    // @arc4.abimethod()
    // def verify_biguint_or_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:237
    // result = a_biguint | b
    frame_dig -1
    itob
    frame_dig -2
    b|
    // tests/artifacts/PrimitiveOps/contract.py:238
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_xor(a: bytes, b: bytes) -> bytes:
verify_biguint_xor:
    // tests/artifacts/PrimitiveOps/contract.py:240-241
    // @arc4.abimethod()
    // def verify_biguint_xor(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:244
    // result = a_biguint ^ b_biguint
    frame_dig -2
    frame_dig -1
    b^
    // tests/artifacts/PrimitiveOps/contract.py:245
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_xor_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_xor_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:247-248
    // @arc4.abimethod()
    // def verify_biguint_xor_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:250
    // result = a_biguint ^ b
    frame_dig -1
    itob
    frame_dig -2
    b^
    // tests/artifacts/PrimitiveOps/contract.py:251
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_eq(a: bytes, b: bytes) -> uint64:
verify_biguint_eq:
    // tests/artifacts/PrimitiveOps/contract.py:253-254
    // @arc4.abimethod()
    // def verify_biguint_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:257
    // result = a_biguint == b_biguint
    frame_dig -2
    frame_dig -1
    b==
    // tests/artifacts/PrimitiveOps/contract.py:258
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_eq_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_eq_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:260-261
    // @arc4.abimethod()
    // def verify_biguint_eq_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:263
    // result = a_biguint == b
    frame_dig -1
    itob
    frame_dig -2
    b==
    // tests/artifacts/PrimitiveOps/contract.py:264
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ne(a: bytes, b: bytes) -> uint64:
verify_biguint_ne:
    // tests/artifacts/PrimitiveOps/contract.py:266-267
    // @arc4.abimethod()
    // def verify_biguint_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:270
    // result = a_biguint != b_biguint
    frame_dig -2
    frame_dig -1
    b!=
    // tests/artifacts/PrimitiveOps/contract.py:271
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ne_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_ne_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:273-274
    // @arc4.abimethod()
    // def verify_biguint_ne_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:276
    // result = a_biguint != b
    frame_dig -1
    itob
    frame_dig -2
    b!=
    // tests/artifacts/PrimitiveOps/contract.py:277
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_lt(a: bytes, b: bytes) -> uint64:
verify_biguint_lt:
    // tests/artifacts/PrimitiveOps/contract.py:279-280
    // @arc4.abimethod()
    // def verify_biguint_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:283
    // result = a_biguint < b_biguint
    frame_dig -2
    frame_dig -1
    b<
    // tests/artifacts/PrimitiveOps/contract.py:284
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_lt_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_lt_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:286-287
    // @arc4.abimethod()
    // def verify_biguint_lt_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:289
    // result = a_biguint < b
    frame_dig -1
    itob
    frame_dig -2
    b>
    // tests/artifacts/PrimitiveOps/contract.py:290
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_le(a: bytes, b: bytes) -> uint64:
verify_biguint_le:
    // tests/artifacts/PrimitiveOps/contract.py:292-293
    // @arc4.abimethod()
    // def verify_biguint_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:296
    // result = a_biguint <= b_biguint
    frame_dig -2
    frame_dig -1
    b<=
    // tests/artifacts/PrimitiveOps/contract.py:297
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_le_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_le_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:299-300
    // @arc4.abimethod()
    // def verify_biguint_le_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:302
    // result = a_biguint <= b
    frame_dig -1
    itob
    frame_dig -2
    b>=
    // tests/artifacts/PrimitiveOps/contract.py:303
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_gt(a: bytes, b: bytes) -> uint64:
verify_biguint_gt:
    // tests/artifacts/PrimitiveOps/contract.py:305-306
    // @arc4.abimethod()
    // def verify_biguint_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:309
    // result = a_biguint > b_biguint
    frame_dig -2
    frame_dig -1
    b>
    // tests/artifacts/PrimitiveOps/contract.py:310
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_gt_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_gt_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:312-313
    // @arc4.abimethod()
    // def verify_biguint_gt_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:315
    // result = a_biguint > b
    frame_dig -1
    itob
    frame_dig -2
    b<
    // tests/artifacts/PrimitiveOps/contract.py:316
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ge(a: bytes, b: bytes) -> uint64:
verify_biguint_ge:
    // tests/artifacts/PrimitiveOps/contract.py:318-319
    // @arc4.abimethod()
    // def verify_biguint_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:322
    // result = a_biguint >= b_biguint
    frame_dig -2
    frame_dig -1
    b>=
    // tests/artifacts/PrimitiveOps/contract.py:323
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ge_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_ge_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:325-326
    // @arc4.abimethod()
    // def verify_biguint_ge_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:328
    // result = a_biguint >= b
    frame_dig -1
    itob
    frame_dig -2
    b<=
    // tests/artifacts/PrimitiveOps/contract.py:329
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_init(a: bytes) -> bytes:
verify_string_init:
    // tests/artifacts/PrimitiveOps/contract.py:331-332
    // @arc4.abimethod
    // def verify_string_init(self, a: String) -> String:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:333
    // result = String("Hello, ") + a
    byte "Hello, "
    frame_dig -1
    concat
    // tests/artifacts/PrimitiveOps/contract.py:334
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_startswith(a: bytes, b: bytes) -> uint64:
verify_string_startswith:
    // tests/artifacts/PrimitiveOps/contract.py:336-337
    // @arc4.abimethod
    // def verify_string_startswith(self, a: String, b: String) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:338
    // result = a.startswith(b)
    frame_dig -1
    len
    dup
    frame_dig -2
    len
    >
    bz verify_string_startswith_ternary_false@2
    int 0
    b verify_string_startswith_ternary_merge@3

verify_string_startswith_ternary_false@2:
    // tests/artifacts/PrimitiveOps/contract.py:338
    // result = a.startswith(b)
    frame_dig -2
    int 0
    frame_dig 0
    extract3
    frame_dig -1
    ==

verify_string_startswith_ternary_merge@3:
    // tests/artifacts/PrimitiveOps/contract.py:339
    // return result
    swap
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_endswith(a: bytes, b: bytes) -> uint64:
verify_string_endswith:
    // tests/artifacts/PrimitiveOps/contract.py:341-342
    // @arc4.abimethod
    // def verify_string_endswith(self, a: String, b: String) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:343
    // result = a.endswith(b)
    frame_dig -1
    len
    dup
    frame_dig -2
    len
    dup
    cover 2
    >
    bz verify_string_endswith_ternary_false@2
    int 0
    b verify_string_endswith_ternary_merge@3

verify_string_endswith_ternary_false@2:
    // tests/artifacts/PrimitiveOps/contract.py:343
    // result = a.endswith(b)
    frame_dig 1
    frame_dig 0
    dup
    cover 2
    -
    frame_dig -2
    swap
    uncover 2
    extract3
    frame_dig -1
    ==

verify_string_endswith_ternary_merge@3:
    // tests/artifacts/PrimitiveOps/contract.py:344
    // return result
    frame_bury 0
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_join(a: bytes, b: bytes) -> bytes:
verify_string_join:
    // tests/artifacts/PrimitiveOps/contract.py:346-347
    // @arc4.abimethod
    // def verify_string_join(self, a: String, b: String) -> String:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:348
    // result = String(", ").join((a, b))
    frame_dig -2
    byte ", "
    concat
    frame_dig -1
    concat
    // tests/artifacts/PrimitiveOps/contract.py:349
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_log(a: bytes, b: uint64, c: bytes, d: bytes, e: bytes, f: bytes, g: bytes, h: bytes, i: bytes, j: bytes, k: bytes, m: bytes, n: bytes) -> void:
verify_log:
    // tests/artifacts/PrimitiveOps/contract.py:351-367
    // @arc4.abimethod
    // def verify_log(  # noqa: PLR0913
    //     self,
    //     a: String,
    //     b: UInt64,
    //     c: Bytes,
    //     d: Bytes,
    //     e: arc4.Bool,
    //     f: arc4.String,
    //     g: arc4.UIntN[typing.Literal[64]],
    //     h: arc4.BigUIntN[typing.Literal[256]],
    //     i: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
    //     j: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
    //     k: Bytes,
    //     m: Bytes,
    //     n: Bytes,
    // ) -> None:
    proto 13 0
    // tests/artifacts/PrimitiveOps/contract.py:372
    // log(a, b, c, d_biguint, e, f, g, h, i, j, arc4_k, arc4_m, arc4_n, sep="-")
    frame_dig -13
    byte "-"
    concat
    frame_dig -12
    itob
    concat
    byte "-"
    concat
    frame_dig -11
    concat
    byte "-"
    concat
    frame_dig -10
    concat
    byte "-"
    concat
    frame_dig -9
    concat
    byte "-"
    concat
    frame_dig -8
    concat
    byte "-"
    concat
    frame_dig -7
    concat
    byte "-"
    concat
    frame_dig -6
    concat
    byte "-"
    concat
    frame_dig -5
    concat
    byte "-"
    concat
    frame_dig -4
    concat
    byte "-"
    concat
    frame_dig -3
    concat
    byte "-"
    concat
    frame_dig -2
    concat
    byte "-"
    concat
    frame_dig -1
    concat
    log
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuUHJpbWl0aXZlT3BzLmNvbnRyYWN0LlByaW1pdGl2ZU9wc0NvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvUHJpbWl0aXZlT3BzL2NvbnRyYWN0LnB5OjYKICAgIC8vIGNsYXNzIFByaW1pdGl2ZU9wc0NvbnRyYWN0KEFSQzRDb250cmFjdCk6CiAgICBpbnQgMQogICAgcmV0dXJuCg=="
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 0x00 "-"
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@65
    pushbytess 0x725c692b 0x17314559 0x53f34893 0x88c8b269 0xa464b7ab 0x9c8b11b8 0x6f40654e 0xec9a2974 0xc793708f 0x7ddb7499 0xa21c443d 0x6e7fb212 0xb007fcb0 0x2ebc20d4 0xb0954b66 0xdd140aef 0xace474da 0xba694990 0x6db581c0 0x91c8db89 0xdbe77158 0x9a0f22e1 0x64033d37 0x2a7237c5 0xe3a94458 0x42f87f7d 0x2b5542a4 0x9be2fbe9 0x1cd92515 0x64e1705c 0xf1271c50 0x2ab63b70 0x834bb7d2 0x531620d7 0x3fb9e769 0xfa8db0bc 0xa72ea485 0xb7b0ba19 0x74460c42 0xab320738 0x52ad4654 0x10156399 0x0f075957 0xbd843dff 0xb377d381 0x89767265 0x456b4b23 0x33d1b88c 0x6bf973ea 0x67cd6bb2 0x3f58805a 0x1e130039 0x509dc91d 0xa564a202 0x23650763 0xf8c8f8d5 0x23faf7a4 0x7d0afe15 0x48581adf 0xe007c10b // method "verify_uint64_init(byte[])uint64", method "verify_uint64_add(uint64,uint64)uint64", method "verify_uint64_sub(uint64,uint64)uint64", method "verify_uint64_mul(uint64,uint64)uint64", method "verify_uint64_div(uint64,uint64)uint64", method "verify_uint64_mod(uint64,uint64)uint64", method "verify_uint64_and(uint64,uint64)uint64", method "verify_uint64_or(uint64,uint64)uint64", method "verify_uint64_xor(uint64,uint64)uint64", method "verify_uint64_not(uint64)uint64", method "verify_uint64_lshift(uint64,uint64)uint64", method "verify_uint64_rshift(uint64,uint64)uint64", method "verify_uint64_pow(uint64,uint64)uint64", method "verify_uint64_eq(uint64,uint64)bool", method "verify_uint64_ne(uint64,uint64)bool", method "verify_uint64_lt(uint64,uint64)bool", method "verify_uint64_le(uint64,uint64)bool", method "verify_uint64_gt(uint64,uint64)bool", method "verify_uint64_ge(uint64,uint64)bool", method "verify_bytes_init(uint64)byte[]", method "verify_bytes_add(byte[],byte[],uint64,uint64)byte[]", method "verify_bytes_eq(byte[],byte[])bool", method "verify_bytes_ne(byte[],byte[])bool", method "verify_bytes_and(byte[],byte[])byte[]", method "verify_bytes_or(byte[],byte[])byte[]", method "verify_bytes_xor(byte[],byte[])byte[]", method "verify_bytes_not(byte[],uint64)byte[]", method "verify_biguint_add(byte[],byte[])byte[]", method "verify_biguint_add_uint64(byte[],uint64)byte[]", method "verify_biguint_sub(byte[],byte[])byte[]", method "verify_biguint_sub_uint64(byte[],uint64)byte[]", method "verify_biguint_mul(byte[],byte[])byte[]", method "verify_biguint_mul_uint64(byte[],uint64)byte[]", method "verify_biguint_div(byte[],byte[])byte[]", method "verify_biguint_div_uint64(byte[],uint64)byte[]", method "verify_biguint_mod(byte[],byte[])byte[]", method "verify_biguint_mod_uint64(byte[],uint64)byte[]", method "verify_biguint_and(byte[],byte[])byte[]", method "verify_biguint_and_uint64(byte[],uint64)byte[]", method "verify_biguint_or(byte[],byte[])byte[]", method "verify_biguint_or_uint64(byte[],uint64)byte[]", method "verify_biguint_xor(byte[],byte[])byte[]", method "verify_biguint_xor_uint64(byte[],uint64)byte[]", method "verify_biguint_eq(byte[],byte[])bool", method "verify_biguint_eq_uint64(byte[],uint64)bool", method "verify_biguint_ne(byte[],byte[])bool", method "verify_biguint_ne_uint64(byte[],uint64)bool", method "verify_biguint_lt(byte[],byte[])bool", method "verify_biguint_lt_uint64(byte[],uint64)bool", method "verify_biguint_le(byte[],byte[])bool", method "verify_biguint_le_uint64(byte[],uint64)bool", method "verify_biguint_gt(byte[],byte[])bool", method "verify_biguint_gt_uint64(byte[],uint64)bool", method "verify_biguint_ge(byte[],byte[])bool", method "verify_biguint_ge_uint64(byte[],uint64)bool", method "verify_string_init(string)string", method "verify_string_startswith(string,string)bool", method "verify_string_endswith(string,string)bool", method "verify_string_join(string,string)string", method "verify_log(string,uint64,byte[],byte[],bool,string,uint64,uint256,ufixed32x8,ufixed256x16,byte[],byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_uint64_init_route@3 main_verify_uint64_add_route@4 main_verify_uint64_sub_route@5 main_verify_uint64_mul_route@6 main_verify_uint64_div_route@7 main_verify_uint64_mod_route@8 main_verify_uint64_and_route@9 main_verify_uint64_or_route@10 main_verify_uint64_xor_route@11 main_verify_uint64_not_route@12 main_verify_uint64_lshift_route@13 main_verify_uint64_rshift_route@14 main_verify_uint64_pow_route@15 main_verify_uint64_eq_route@16 main_verify_uint64_ne_route@17 main_verify_uint64_lt_route@18 main_verify_uint64_le_route@19 main_verify_uint64_gt_route@20 main_verify_uint64_ge_route@21 main_verify_bytes_init_route@22 main_verify_bytes_add_route@23 main_verify_bytes_eq_route@24 main_verify_bytes_ne_route@25 main_verify_bytes_and_route@26 main_verify_bytes_or_route@27 main_verify_bytes_xor_route@28 main_verify_bytes_not_route@29 main_verify_biguint_add_route@30 main_verify_biguint_add_uint64_route@31 main_verify_biguint_sub_route@32 main_verify_biguint_sub_uint64_route@33 main_verify_biguint_mul_route@34 main_verify_biguint_mul_uint64_route@35 main_verify_biguint_div_route@36 main_verify_biguint_div_uint64_route@37 main_verify_biguint_mod_route@38 main_verify_biguint_mod_uint64_route@39 main_verify_biguint_and_route@40 main_verify_biguint_and_uint64_route@41 main_verify_biguint_or_route@42 main_verify_biguint_or_uint64_route@43 main_verify_biguint_xor_route@44 main_verify_biguint_xor_uint64_route@45 main_verify_biguint_eq_route@46 main_verify_biguint_eq_uint64_route@47 main_verify_biguint_ne_route@48 main_verify_biguint_ne_uint64_route@49 main_verify_biguint_lt_route@50 main_verify_biguint_lt_uint64_route@51 main_verify_biguint_le_route@52 main_verify_biguint_le_uint64_route@53 main_verify_biguint_gt_route@54 main_verify_biguint_gt_uint64_route@55 main_verify_biguint_ge_route@56 main_verify_biguint_ge_uint64_route@57 main_verify_string_init_route@58 main_verify_string_startswith_route@59 main_verify_string_endswith_route@60 main_verify_string_join_route@61 main_verify_log_route@62

main_after_if_else@69:
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    intc_1 // 0
    return

main_verify_log_route@62:
    // tests/artifacts/PrimitiveOps/contract.py:351
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    txna ApplicationArgs 4
    extract 2 0
    txna ApplicationArgs 5
    txna ApplicationArgs 6
    txna ApplicationArgs 7
    txna ApplicationArgs 8
    txna ApplicationArgs 9
    txna ApplicationArgs 10
    txna ApplicationArgs 11
    extract 2 0
    txna ApplicationArgs 12
    extract 2 0
    txna ApplicationArgs 13
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:351
    // @arc4.abimethod
    callsub verify_log
    intc_0 // 1
    return

main_verify_string_join_route@61:
    // tests/artifacts/PrimitiveOps/contract.py:346
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:346
    // @arc4.abimethod
    callsub verify_string_join
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_endswith_route@60:
    // tests/artifacts/PrimitiveOps/contract.py:341
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:341
    // @arc4.abimethod
    callsub verify_string_endswith
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_string_startswith_route@59:
    // tests/artifacts/PrimitiveOps/contract.py:336
    // @arc4.abimethod
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:336
    // @arc4.abimethod
    callsub verify_string_startswith
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

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

main_verify_biguint_ge_uint64_route@57:
    // tests/artifacts/PrimitiveOps/contract.py:325
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:325
    // @arc4.abimethod()
    callsub verify_biguint_ge_uint64
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_ge_route@56:
    // tests/artifacts/PrimitiveOps/contract.py:318
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:318
    // @arc4.abimethod()
    callsub verify_biguint_ge
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_gt_uint64_route@55:
    // tests/artifacts/PrimitiveOps/contract.py:312
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:312
    // @arc4.abimethod()
    callsub verify_biguint_gt_uint64
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_gt_route@54:
    // tests/artifacts/PrimitiveOps/contract.py:305
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:305
    // @arc4.abimethod()
    callsub verify_biguint_gt
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_le_uint64_route@53:
    // tests/artifacts/PrimitiveOps/contract.py:299
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:299
    // @arc4.abimethod()
    callsub verify_biguint_le_uint64
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_le_route@52:
    // tests/artifacts/PrimitiveOps/contract.py:292
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:292
    // @arc4.abimethod()
    callsub verify_biguint_le
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_lt_uint64_route@51:
    // tests/artifacts/PrimitiveOps/contract.py:286
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:286
    // @arc4.abimethod()
    callsub verify_biguint_lt_uint64
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_lt_route@50:
    // tests/artifacts/PrimitiveOps/contract.py:279
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:279
    // @arc4.abimethod()
    callsub verify_biguint_lt
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_ne_uint64_route@49:
    // tests/artifacts/PrimitiveOps/contract.py:273
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:273
    // @arc4.abimethod()
    callsub verify_biguint_ne_uint64
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_ne_route@48:
    // tests/artifacts/PrimitiveOps/contract.py:266
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:266
    // @arc4.abimethod()
    callsub verify_biguint_ne
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_eq_uint64_route@47:
    // tests/artifacts/PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:260
    // @arc4.abimethod()
    callsub verify_biguint_eq_uint64
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_eq_route@46:
    // tests/artifacts/PrimitiveOps/contract.py:253
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:253
    // @arc4.abimethod()
    callsub verify_biguint_eq
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

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

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

main_verify_biguint_or_uint64_route@43:
    // tests/artifacts/PrimitiveOps/contract.py:234
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:234
    // @arc4.abimethod()
    callsub verify_biguint_or_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

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

main_verify_biguint_and_uint64_route@41:
    // tests/artifacts/PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:221
    // @arc4.abimethod()
    callsub verify_biguint_and_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_and_route@40:
    // tests/artifacts/PrimitiveOps/contract.py:214
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:214
    // @arc4.abimethod()
    callsub verify_biguint_and
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_mod_uint64_route@39:
    // tests/artifacts/PrimitiveOps/contract.py:208
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:208
    // @arc4.abimethod()
    callsub verify_biguint_mod_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_mod_route@38:
    // tests/artifacts/PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:201
    // @arc4.abimethod()
    callsub verify_biguint_mod
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_div_uint64_route@37:
    // tests/artifacts/PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:195
    // @arc4.abimethod()
    callsub verify_biguint_div_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_div_route@36:
    // tests/artifacts/PrimitiveOps/contract.py:188
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:188
    // @arc4.abimethod()
    callsub verify_biguint_div
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_mul_uint64_route@35:
    // tests/artifacts/PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:182
    // @arc4.abimethod()
    callsub verify_biguint_mul_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

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

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

main_verify_biguint_sub_route@32:
    // tests/artifacts/PrimitiveOps/contract.py:162
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:162
    // @arc4.abimethod()
    callsub verify_biguint_sub
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_add_uint64_route@31:
    // tests/artifacts/PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:156
    // @arc4.abimethod()
    callsub verify_biguint_add_uint64
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_biguint_add_route@30:
    // tests/artifacts/PrimitiveOps/contract.py:149
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:149
    // @arc4.abimethod()
    callsub verify_biguint_add
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_not_route@29:
    // tests/artifacts/PrimitiveOps/contract.py:142
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:142
    // @arc4.abimethod()
    callsub verify_bytes_not
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_xor_route@28:
    // tests/artifacts/PrimitiveOps/contract.py:137
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:137
    // @arc4.abimethod()
    callsub verify_bytes_xor
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_or_route@27:
    // tests/artifacts/PrimitiveOps/contract.py:132
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:132
    // @arc4.abimethod()
    callsub verify_bytes_or
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_and_route@26:
    // tests/artifacts/PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:127
    // @arc4.abimethod()
    callsub verify_bytes_and
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

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

main_verify_bytes_eq_route@24:
    // tests/artifacts/PrimitiveOps/contract.py:117
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:117
    // @arc4.abimethod()
    callsub verify_bytes_eq
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_add_route@23:
    // tests/artifacts/PrimitiveOps/contract.py:107
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:107
    // @arc4.abimethod()
    callsub verify_bytes_add
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_bytes_init_route@22:
    // tests/artifacts/PrimitiveOps/contract.py:102
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:102
    // @arc4.abimethod()
    callsub verify_bytes_init
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_ge_route@21:
    // tests/artifacts/PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:97
    // @arc4.abimethod()
    callsub verify_uint64_ge
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_gt_route@20:
    // tests/artifacts/PrimitiveOps/contract.py:92
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:92
    // @arc4.abimethod()
    callsub verify_uint64_gt
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_le_route@19:
    // tests/artifacts/PrimitiveOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_uint64_le
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_lt_route@18:
    // tests/artifacts/PrimitiveOps/contract.py:82
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:82
    // @arc4.abimethod()
    callsub verify_uint64_lt
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_ne_route@17:
    // tests/artifacts/PrimitiveOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_uint64_ne
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_eq_route@16:
    // tests/artifacts/PrimitiveOps/contract.py:72
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:72
    // @arc4.abimethod()
    callsub verify_uint64_eq
    bytec_1 // 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_pow_route@15:
    // tests/artifacts/PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_uint64_pow
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_rshift_route@14:
    // tests/artifacts/PrimitiveOps/contract.py:62
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:62
    // @arc4.abimethod()
    callsub verify_uint64_rshift
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_lshift_route@13:
    // tests/artifacts/PrimitiveOps/contract.py:57
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:57
    // @arc4.abimethod()
    callsub verify_uint64_lshift
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_not_route@12:
    // tests/artifacts/PrimitiveOps/contract.py:52
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:52
    // @arc4.abimethod()
    callsub verify_uint64_not
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_xor_route@11:
    // tests/artifacts/PrimitiveOps/contract.py:47
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:47
    // @arc4.abimethod()
    callsub verify_uint64_xor
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_or_route@10:
    // tests/artifacts/PrimitiveOps/contract.py:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:42
    // @arc4.abimethod()
    callsub verify_uint64_or
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_and_route@9:
    // tests/artifacts/PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:37
    // @arc4.abimethod()
    callsub verify_uint64_and
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_mod_route@8:
    // tests/artifacts/PrimitiveOps/contract.py:32
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:32
    // @arc4.abimethod()
    callsub verify_uint64_mod
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_div_route@7:
    // tests/artifacts/PrimitiveOps/contract.py:27
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:27
    // @arc4.abimethod()
    callsub verify_uint64_div
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_mul_route@6:
    // tests/artifacts/PrimitiveOps/contract.py:22
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:22
    // @arc4.abimethod()
    callsub verify_uint64_mul
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_sub_route@5:
    // tests/artifacts/PrimitiveOps/contract.py:17
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:17
    // @arc4.abimethod()
    callsub verify_uint64_sub
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_add_route@4:
    // tests/artifacts/PrimitiveOps/contract.py:12
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:12
    // @arc4.abimethod()
    callsub verify_uint64_add
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_uint64_init_route@3:
    // tests/artifacts/PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/PrimitiveOps/contract.py:7
    // @arc4.abimethod()
    callsub verify_uint64_init
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@65:
    // tests/artifacts/PrimitiveOps/contract.py:6
    // class PrimitiveOpsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@69
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_init(raw_value: bytes) -> uint64:
verify_uint64_init:
    // tests/artifacts/PrimitiveOps/contract.py:7-8
    // @arc4.abimethod()
    // def verify_uint64_init(self, raw_value: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:9
    // result = op.btoi(raw_value)
    frame_dig -1
    btoi
    // tests/artifacts/PrimitiveOps/contract.py:10
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_add(a: uint64, b: uint64) -> uint64:
verify_uint64_add:
    // tests/artifacts/PrimitiveOps/contract.py:12-13
    // @arc4.abimethod()
    // def verify_uint64_add(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:14
    // result = a + b
    frame_dig -2
    frame_dig -1
    +
    // tests/artifacts/PrimitiveOps/contract.py:15
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_sub(a: uint64, b: uint64) -> uint64:
verify_uint64_sub:
    // tests/artifacts/PrimitiveOps/contract.py:17-18
    // @arc4.abimethod()
    // def verify_uint64_sub(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:19
    // result = a - b
    frame_dig -2
    frame_dig -1
    -
    // tests/artifacts/PrimitiveOps/contract.py:20
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_mul(a: uint64, b: uint64) -> uint64:
verify_uint64_mul:
    // tests/artifacts/PrimitiveOps/contract.py:22-23
    // @arc4.abimethod()
    // def verify_uint64_mul(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:24
    // result = a * b
    frame_dig -2
    frame_dig -1
    *
    // tests/artifacts/PrimitiveOps/contract.py:25
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_div(a: uint64, b: uint64) -> uint64:
verify_uint64_div:
    // tests/artifacts/PrimitiveOps/contract.py:27-28
    // @arc4.abimethod()
    // def verify_uint64_div(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:29
    // result = a // b
    frame_dig -2
    frame_dig -1
    /
    // tests/artifacts/PrimitiveOps/contract.py:30
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_mod(a: uint64, b: uint64) -> uint64:
verify_uint64_mod:
    // tests/artifacts/PrimitiveOps/contract.py:32-33
    // @arc4.abimethod()
    // def verify_uint64_mod(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:34
    // result = a % b
    frame_dig -2
    frame_dig -1
    %
    // tests/artifacts/PrimitiveOps/contract.py:35
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_and(a: uint64, b: uint64) -> uint64:
verify_uint64_and:
    // tests/artifacts/PrimitiveOps/contract.py:37-38
    // @arc4.abimethod()
    // def verify_uint64_and(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:39
    // result = a & b
    frame_dig -2
    frame_dig -1
    &
    // tests/artifacts/PrimitiveOps/contract.py:40
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_or(a: uint64, b: uint64) -> uint64:
verify_uint64_or:
    // tests/artifacts/PrimitiveOps/contract.py:42-43
    // @arc4.abimethod()
    // def verify_uint64_or(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:44
    // result = a | b
    frame_dig -2
    frame_dig -1
    |
    // tests/artifacts/PrimitiveOps/contract.py:45
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_xor(a: uint64, b: uint64) -> uint64:
verify_uint64_xor:
    // tests/artifacts/PrimitiveOps/contract.py:47-48
    // @arc4.abimethod()
    // def verify_uint64_xor(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:49
    // result = a ^ b
    frame_dig -2
    frame_dig -1
    ^
    // tests/artifacts/PrimitiveOps/contract.py:50
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_not(a: uint64) -> uint64:
verify_uint64_not:
    // tests/artifacts/PrimitiveOps/contract.py:52-53
    // @arc4.abimethod()
    // def verify_uint64_not(self, a: UInt64) -> UInt64:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:54
    // result = ~a
    frame_dig -1
    ~
    // tests/artifacts/PrimitiveOps/contract.py:55
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_lshift(a: uint64, b: uint64) -> uint64:
verify_uint64_lshift:
    // tests/artifacts/PrimitiveOps/contract.py:57-58
    // @arc4.abimethod()
    // def verify_uint64_lshift(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:59
    // result = a << b
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/PrimitiveOps/contract.py:60
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_rshift(a: uint64, b: uint64) -> uint64:
verify_uint64_rshift:
    // tests/artifacts/PrimitiveOps/contract.py:62-63
    // @arc4.abimethod()
    // def verify_uint64_rshift(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:64
    // result = a >> b
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/PrimitiveOps/contract.py:65
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_pow(a: uint64, b: uint64) -> uint64:
verify_uint64_pow:
    // tests/artifacts/PrimitiveOps/contract.py:67-68
    // @arc4.abimethod()
    // def verify_uint64_pow(self, a: UInt64, b: UInt64) -> UInt64:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:69
    // result = a**b
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/PrimitiveOps/contract.py:70
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_eq(a: uint64, b: uint64) -> uint64:
verify_uint64_eq:
    // tests/artifacts/PrimitiveOps/contract.py:72-73
    // @arc4.abimethod()
    // def verify_uint64_eq(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:74
    // result = a == b
    frame_dig -2
    frame_dig -1
    ==
    // tests/artifacts/PrimitiveOps/contract.py:75
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_ne(a: uint64, b: uint64) -> uint64:
verify_uint64_ne:
    // tests/artifacts/PrimitiveOps/contract.py:77-78
    // @arc4.abimethod()
    // def verify_uint64_ne(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:79
    // result = a != b
    frame_dig -2
    frame_dig -1
    !=
    // tests/artifacts/PrimitiveOps/contract.py:80
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_lt(a: uint64, b: uint64) -> uint64:
verify_uint64_lt:
    // tests/artifacts/PrimitiveOps/contract.py:82-83
    // @arc4.abimethod()
    // def verify_uint64_lt(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:84
    // result = a < b
    frame_dig -2
    frame_dig -1
    <
    // tests/artifacts/PrimitiveOps/contract.py:85
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_le(a: uint64, b: uint64) -> uint64:
verify_uint64_le:
    // tests/artifacts/PrimitiveOps/contract.py:87-88
    // @arc4.abimethod()
    // def verify_uint64_le(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:89
    // result = a <= b
    frame_dig -2
    frame_dig -1
    <=
    // tests/artifacts/PrimitiveOps/contract.py:90
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_gt(a: uint64, b: uint64) -> uint64:
verify_uint64_gt:
    // tests/artifacts/PrimitiveOps/contract.py:92-93
    // @arc4.abimethod()
    // def verify_uint64_gt(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:94
    // result = a > b
    frame_dig -2
    frame_dig -1
    >
    // tests/artifacts/PrimitiveOps/contract.py:95
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_uint64_ge(a: uint64, b: uint64) -> uint64:
verify_uint64_ge:
    // tests/artifacts/PrimitiveOps/contract.py:97-98
    // @arc4.abimethod()
    // def verify_uint64_ge(self, a: UInt64, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:99
    // result = a >= b
    frame_dig -2
    frame_dig -1
    >=
    // tests/artifacts/PrimitiveOps/contract.py:100
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_init(raw_value: uint64) -> bytes:
verify_bytes_init:
    // tests/artifacts/PrimitiveOps/contract.py:102-103
    // @arc4.abimethod()
    // def verify_bytes_init(self, raw_value: UInt64) -> Bytes:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:104
    // result = op.itob(raw_value)
    frame_dig -1
    itob
    // tests/artifacts/PrimitiveOps/contract.py:105
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_add(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_bytes_add:
    // tests/artifacts/PrimitiveOps/contract.py:107-110
    // @arc4.abimethod()
    // def verify_bytes_add(
    //     self, a: Bytes, b: Bytes, pad_a_size: UInt64, pad_b_size: UInt64
    // ) -> Bytes:
    proto 4 1
    // tests/artifacts/PrimitiveOps/contract.py:111
    // a = op.bzero(pad_a_size) + a
    frame_dig -2
    bzero
    frame_dig -4
    concat
    frame_bury -4
    // tests/artifacts/PrimitiveOps/contract.py:112
    // b = op.bzero(pad_b_size) + b
    frame_dig -1
    bzero
    frame_dig -3
    concat
    frame_bury -3
    // tests/artifacts/PrimitiveOps/contract.py:113
    // result = a + b
    frame_dig -4
    frame_dig -3
    concat
    // tests/artifacts/PrimitiveOps/contract.py:114
    // result = op.sha256(result)
    sha256
    // tests/artifacts/PrimitiveOps/contract.py:115
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_eq(a: bytes, b: bytes) -> uint64:
verify_bytes_eq:
    // tests/artifacts/PrimitiveOps/contract.py:117-118
    // @arc4.abimethod()
    // def verify_bytes_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:119
    // result = a == b
    frame_dig -2
    frame_dig -1
    ==
    // tests/artifacts/PrimitiveOps/contract.py:120
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_ne(a: bytes, b: bytes) -> uint64:
verify_bytes_ne:
    // tests/artifacts/PrimitiveOps/contract.py:122-123
    // @arc4.abimethod()
    // def verify_bytes_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:124
    // result = a != b
    frame_dig -2
    frame_dig -1
    !=
    // tests/artifacts/PrimitiveOps/contract.py:125
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_and(a: bytes, b: bytes) -> bytes:
verify_bytes_and:
    // tests/artifacts/PrimitiveOps/contract.py:127-128
    // @arc4.abimethod()
    // def verify_bytes_and(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:129
    // result = a & b
    frame_dig -2
    frame_dig -1
    b&
    // tests/artifacts/PrimitiveOps/contract.py:130
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_or(a: bytes, b: bytes) -> bytes:
verify_bytes_or:
    // tests/artifacts/PrimitiveOps/contract.py:132-133
    // @arc4.abimethod()
    // def verify_bytes_or(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:134
    // result = a | b
    frame_dig -2
    frame_dig -1
    b|
    // tests/artifacts/PrimitiveOps/contract.py:135
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_xor(a: bytes, b: bytes) -> bytes:
verify_bytes_xor:
    // tests/artifacts/PrimitiveOps/contract.py:137-138
    // @arc4.abimethod()
    // def verify_bytes_xor(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:139
    // result = a ^ b
    frame_dig -2
    frame_dig -1
    b^
    // tests/artifacts/PrimitiveOps/contract.py:140
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_bytes_not(a: bytes, pad_size: uint64) -> bytes:
verify_bytes_not:
    // tests/artifacts/PrimitiveOps/contract.py:142-143
    // @arc4.abimethod()
    // def verify_bytes_not(self, a: Bytes, pad_size: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:144
    // a = op.bzero(pad_size) + a
    frame_dig -1
    bzero
    frame_dig -2
    concat
    dup
    frame_bury -2
    // tests/artifacts/PrimitiveOps/contract.py:145
    // result = ~a
    b~
    // tests/artifacts/PrimitiveOps/contract.py:146
    // result = op.sha256(result)
    sha256
    // tests/artifacts/PrimitiveOps/contract.py:147
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_add(a: bytes, b: bytes) -> bytes:
verify_biguint_add:
    // tests/artifacts/PrimitiveOps/contract.py:149-150
    // @arc4.abimethod()
    // def verify_biguint_add(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:153
    // result = a_biguint + b_biguint
    frame_dig -2
    frame_dig -1
    b+
    // tests/artifacts/PrimitiveOps/contract.py:154
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_add_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_add_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:156-157
    // @arc4.abimethod()
    // def verify_biguint_add_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:159
    // result = a_biguint + b
    frame_dig -1
    itob
    frame_dig -2
    b+
    // tests/artifacts/PrimitiveOps/contract.py:160
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_sub(a: bytes, b: bytes) -> bytes:
verify_biguint_sub:
    // tests/artifacts/PrimitiveOps/contract.py:162-163
    // @arc4.abimethod()
    // def verify_biguint_sub(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:166
    // result = a_biguint - b_biguint
    frame_dig -2
    frame_dig -1
    b-
    // tests/artifacts/PrimitiveOps/contract.py:167
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_sub_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_sub_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:169-170
    // @arc4.abimethod()
    // def verify_biguint_sub_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:172
    // result = a_biguint - b
    frame_dig -1
    itob
    frame_dig -2
    swap
    b-
    // tests/artifacts/PrimitiveOps/contract.py:173
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mul(a: bytes, b: bytes) -> bytes:
verify_biguint_mul:
    // tests/artifacts/PrimitiveOps/contract.py:175-176
    // @arc4.abimethod()
    // def verify_biguint_mul(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:179
    // result = a_biguint * b_biguint
    frame_dig -2
    frame_dig -1
    b*
    // tests/artifacts/PrimitiveOps/contract.py:180
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mul_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_mul_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:182-183
    // @arc4.abimethod()
    // def verify_biguint_mul_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:185
    // result = a_biguint * b
    frame_dig -1
    itob
    frame_dig -2
    b*
    // tests/artifacts/PrimitiveOps/contract.py:186
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_div(a: bytes, b: bytes) -> bytes:
verify_biguint_div:
    // tests/artifacts/PrimitiveOps/contract.py:188-189
    // @arc4.abimethod()
    // def verify_biguint_div(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:192
    // result = a_biguint // b_biguint
    frame_dig -2
    frame_dig -1
    b/
    // tests/artifacts/PrimitiveOps/contract.py:193
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_div_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_div_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:195-196
    // @arc4.abimethod()
    // def verify_biguint_div_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:198
    // result = a_biguint // b
    frame_dig -1
    itob
    frame_dig -2
    swap
    b/
    // tests/artifacts/PrimitiveOps/contract.py:199
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mod(a: bytes, b: bytes) -> bytes:
verify_biguint_mod:
    // tests/artifacts/PrimitiveOps/contract.py:201-202
    // @arc4.abimethod()
    // def verify_biguint_mod(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:205
    // result = a_biguint % b_biguint
    frame_dig -2
    frame_dig -1
    b%
    // tests/artifacts/PrimitiveOps/contract.py:206
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_mod_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_mod_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:208-209
    // @arc4.abimethod()
    // def verify_biguint_mod_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:211
    // result = a_biguint % b
    frame_dig -1
    itob
    frame_dig -2
    swap
    b%
    // tests/artifacts/PrimitiveOps/contract.py:212
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_and(a: bytes, b: bytes) -> bytes:
verify_biguint_and:
    // tests/artifacts/PrimitiveOps/contract.py:214-215
    // @arc4.abimethod()
    // def verify_biguint_and(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:218
    // result = a_biguint & b_biguint
    frame_dig -2
    frame_dig -1
    b&
    // tests/artifacts/PrimitiveOps/contract.py:219
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_and_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_and_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:221-222
    // @arc4.abimethod()
    // def verify_biguint_and_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:224
    // result = a_biguint & b
    frame_dig -1
    itob
    frame_dig -2
    b&
    // tests/artifacts/PrimitiveOps/contract.py:225
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_or(a: bytes, b: bytes) -> bytes:
verify_biguint_or:
    // tests/artifacts/PrimitiveOps/contract.py:227-228
    // @arc4.abimethod()
    // def verify_biguint_or(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:231
    // result = a_biguint | b_biguint
    frame_dig -2
    frame_dig -1
    b|
    // tests/artifacts/PrimitiveOps/contract.py:232
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_or_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_or_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:234-235
    // @arc4.abimethod()
    // def verify_biguint_or_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:237
    // result = a_biguint | b
    frame_dig -1
    itob
    frame_dig -2
    b|
    // tests/artifacts/PrimitiveOps/contract.py:238
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_xor(a: bytes, b: bytes) -> bytes:
verify_biguint_xor:
    // tests/artifacts/PrimitiveOps/contract.py:240-241
    // @arc4.abimethod()
    // def verify_biguint_xor(self, a: Bytes, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:244
    // result = a_biguint ^ b_biguint
    frame_dig -2
    frame_dig -1
    b^
    // tests/artifacts/PrimitiveOps/contract.py:245
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_xor_uint64(a: bytes, b: uint64) -> bytes:
verify_biguint_xor_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:247-248
    // @arc4.abimethod()
    // def verify_biguint_xor_uint64(self, a: Bytes, b: UInt64) -> Bytes:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:250
    // result = a_biguint ^ b
    frame_dig -1
    itob
    frame_dig -2
    b^
    // tests/artifacts/PrimitiveOps/contract.py:251
    // return result.bytes
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_eq(a: bytes, b: bytes) -> uint64:
verify_biguint_eq:
    // tests/artifacts/PrimitiveOps/contract.py:253-254
    // @arc4.abimethod()
    // def verify_biguint_eq(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:257
    // result = a_biguint == b_biguint
    frame_dig -2
    frame_dig -1
    b==
    // tests/artifacts/PrimitiveOps/contract.py:258
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_eq_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_eq_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:260-261
    // @arc4.abimethod()
    // def verify_biguint_eq_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:263
    // result = a_biguint == b
    frame_dig -1
    itob
    frame_dig -2
    b==
    // tests/artifacts/PrimitiveOps/contract.py:264
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ne(a: bytes, b: bytes) -> uint64:
verify_biguint_ne:
    // tests/artifacts/PrimitiveOps/contract.py:266-267
    // @arc4.abimethod()
    // def verify_biguint_ne(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:270
    // result = a_biguint != b_biguint
    frame_dig -2
    frame_dig -1
    b!=
    // tests/artifacts/PrimitiveOps/contract.py:271
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ne_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_ne_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:273-274
    // @arc4.abimethod()
    // def verify_biguint_ne_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:276
    // result = a_biguint != b
    frame_dig -1
    itob
    frame_dig -2
    b!=
    // tests/artifacts/PrimitiveOps/contract.py:277
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_lt(a: bytes, b: bytes) -> uint64:
verify_biguint_lt:
    // tests/artifacts/PrimitiveOps/contract.py:279-280
    // @arc4.abimethod()
    // def verify_biguint_lt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:283
    // result = a_biguint < b_biguint
    frame_dig -2
    frame_dig -1
    b<
    // tests/artifacts/PrimitiveOps/contract.py:284
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_lt_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_lt_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:286-287
    // @arc4.abimethod()
    // def verify_biguint_lt_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:289
    // result = a_biguint < b
    frame_dig -1
    itob
    frame_dig -2
    b>
    // tests/artifacts/PrimitiveOps/contract.py:290
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_le(a: bytes, b: bytes) -> uint64:
verify_biguint_le:
    // tests/artifacts/PrimitiveOps/contract.py:292-293
    // @arc4.abimethod()
    // def verify_biguint_le(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:296
    // result = a_biguint <= b_biguint
    frame_dig -2
    frame_dig -1
    b<=
    // tests/artifacts/PrimitiveOps/contract.py:297
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_le_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_le_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:299-300
    // @arc4.abimethod()
    // def verify_biguint_le_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:302
    // result = a_biguint <= b
    frame_dig -1
    itob
    frame_dig -2
    b>=
    // tests/artifacts/PrimitiveOps/contract.py:303
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_gt(a: bytes, b: bytes) -> uint64:
verify_biguint_gt:
    // tests/artifacts/PrimitiveOps/contract.py:305-306
    // @arc4.abimethod()
    // def verify_biguint_gt(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:309
    // result = a_biguint > b_biguint
    frame_dig -2
    frame_dig -1
    b>
    // tests/artifacts/PrimitiveOps/contract.py:310
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_gt_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_gt_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:312-313
    // @arc4.abimethod()
    // def verify_biguint_gt_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:315
    // result = a_biguint > b
    frame_dig -1
    itob
    frame_dig -2
    b<
    // tests/artifacts/PrimitiveOps/contract.py:316
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ge(a: bytes, b: bytes) -> uint64:
verify_biguint_ge:
    // tests/artifacts/PrimitiveOps/contract.py:318-319
    // @arc4.abimethod()
    // def verify_biguint_ge(self, a: Bytes, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:322
    // result = a_biguint >= b_biguint
    frame_dig -2
    frame_dig -1
    b>=
    // tests/artifacts/PrimitiveOps/contract.py:323
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_biguint_ge_uint64(a: bytes, b: uint64) -> uint64:
verify_biguint_ge_uint64:
    // tests/artifacts/PrimitiveOps/contract.py:325-326
    // @arc4.abimethod()
    // def verify_biguint_ge_uint64(self, a: Bytes, b: UInt64) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:328
    // result = a_biguint >= b
    frame_dig -1
    itob
    frame_dig -2
    b<=
    // tests/artifacts/PrimitiveOps/contract.py:329
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_init(a: bytes) -> bytes:
verify_string_init:
    // tests/artifacts/PrimitiveOps/contract.py:331-332
    // @arc4.abimethod
    // def verify_string_init(self, a: String) -> String:
    proto 1 1
    // tests/artifacts/PrimitiveOps/contract.py:333
    // result = String("Hello, ") + a
    pushbytes "Hello, "
    frame_dig -1
    concat
    // tests/artifacts/PrimitiveOps/contract.py:334
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_startswith(a: bytes, b: bytes) -> uint64:
verify_string_startswith:
    // tests/artifacts/PrimitiveOps/contract.py:336-337
    // @arc4.abimethod
    // def verify_string_startswith(self, a: String, b: String) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:338
    // result = a.startswith(b)
    frame_dig -1
    len
    dup
    frame_dig -2
    len
    >
    bz verify_string_startswith_ternary_false@2
    intc_1 // 0

verify_string_startswith_ternary_merge@3:
    // tests/artifacts/PrimitiveOps/contract.py:339
    // return result
    swap
    retsub

verify_string_startswith_ternary_false@2:
    // tests/artifacts/PrimitiveOps/contract.py:338
    // result = a.startswith(b)
    frame_dig -2
    intc_1 // 0
    frame_dig 0
    extract3
    frame_dig -1
    ==
    b verify_string_startswith_ternary_merge@3


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_endswith(a: bytes, b: bytes) -> uint64:
verify_string_endswith:
    // tests/artifacts/PrimitiveOps/contract.py:341-342
    // @arc4.abimethod
    // def verify_string_endswith(self, a: String, b: String) -> bool:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:343
    // result = a.endswith(b)
    frame_dig -1
    len
    dup
    frame_dig -2
    len
    dup
    cover 2
    >
    bz verify_string_endswith_ternary_false@2
    intc_1 // 0

verify_string_endswith_ternary_merge@3:
    // tests/artifacts/PrimitiveOps/contract.py:344
    // return result
    frame_bury 0
    retsub

verify_string_endswith_ternary_false@2:
    // tests/artifacts/PrimitiveOps/contract.py:343
    // result = a.endswith(b)
    frame_dig 1
    frame_dig 0
    dup
    cover 2
    -
    frame_dig -2
    swap
    uncover 2
    extract3
    frame_dig -1
    ==
    b verify_string_endswith_ternary_merge@3


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_string_join(a: bytes, b: bytes) -> bytes:
verify_string_join:
    // tests/artifacts/PrimitiveOps/contract.py:346-347
    // @arc4.abimethod
    // def verify_string_join(self, a: String, b: String) -> String:
    proto 2 1
    // tests/artifacts/PrimitiveOps/contract.py:348
    // result = String(", ").join((a, b))
    frame_dig -2
    pushbytes ", "
    concat
    frame_dig -1
    concat
    // tests/artifacts/PrimitiveOps/contract.py:349
    // return result
    retsub


// tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.verify_log(a: bytes, b: uint64, c: bytes, d: bytes, e: bytes, f: bytes, g: bytes, h: bytes, i: bytes, j: bytes, k: bytes, m: bytes, n: bytes) -> void:
verify_log:
    // tests/artifacts/PrimitiveOps/contract.py:351-367
    // @arc4.abimethod
    // def verify_log(  # noqa: PLR0913
    //     self,
    //     a: String,
    //     b: UInt64,
    //     c: Bytes,
    //     d: Bytes,
    //     e: arc4.Bool,
    //     f: arc4.String,
    //     g: arc4.UIntN[typing.Literal[64]],
    //     h: arc4.BigUIntN[typing.Literal[256]],
    //     i: arc4.UFixedNxM[typing.Literal[32], typing.Literal[8]],
    //     j: arc4.BigUFixedNxM[typing.Literal[256], typing.Literal[16]],
    //     k: Bytes,
    //     m: Bytes,
    //     n: Bytes,
    // ) -> None:
    proto 13 0
    // tests/artifacts/PrimitiveOps/contract.py:372
    // log(a, b, c, d_biguint, e, f, g, h, i, j, arc4_k, arc4_m, arc4_n, sep="-")
    frame_dig -13
    bytec_2 // "-"
    concat
    frame_dig -12
    itob
    concat
    bytec_2 // "-"
    concat
    frame_dig -11
    concat
    bytec_2 // "-"
    concat
    frame_dig -10
    concat
    bytec_2 // "-"
    concat
    frame_dig -9
    concat
    bytec_2 // "-"
    concat
    frame_dig -8
    concat
    bytec_2 // "-"
    concat
    frame_dig -7
    concat
    bytec_2 // "-"
    concat
    frame_dig -6
    concat
    bytec_2 // "-"
    concat
    frame_dig -5
    concat
    bytec_2 // "-"
    concat
    frame_dig -4
    concat
    bytec_2 // "-"
    concat
    frame_dig -3
    concat
    bytec_2 // "-"
    concat
    frame_dig -2
    concat
    bytec_2 // "-"
    concat
    frame_dig -1
    concat
    log
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.clear.teal b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.clear.teal
index 8341d36..a433105 100644
--- a/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.clear.teal
+++ b/tests/artifacts/PrimitiveOps/data/PrimitiveOpsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.PrimitiveOps.contract.PrimitiveOpsContract.clear_state_program:
-    // tests/artifacts/PrimitiveOps/contract.py:6
-    // class PrimitiveOpsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal b/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal
index 53c9b51..0655a8f 100644
--- a/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal
+++ b/tests/artifacts/StateOps/data/GlobalStateContract.approval.teal
@@ -1,544 +1,594 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.GlobalStateContract.approval_program:
+// tests.artifacts.StateOps.contract.GlobalStateContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75 "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" "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
     txn ApplicationID
-    bnz main_entrypoint@2
-    callsub __init__
+    bnz main_after_if_else@2
+    // tests/artifacts/StateOps/contract.py:516-517
+    // # Implicit key state variables
+    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
+    bytec_1 // "implicit_key_arc4_uint"
+    bytec 15 // 0x0000000000000539
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:518
+    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
+    bytec_2 // "implicit_key_arc4_string"
+    bytec 16 // 0x000548656c6c6f
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:519
+    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
+    bytec_3 // "implicit_key_arc4_byte"
+    pushbytes 0x00
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:520
+    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
+    bytec 4 // "implicit_key_arc4_bool"
+    pushbytes 0x80
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:521
+    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
+    bytec 5 // "implicit_key_arc4_address"
+    global CreatorAddress
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:522
+    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
+    bytec 6 // "implicit_key_arc4_uint128"
+    bytec 17 // 0x00000010000000000000000000000000
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:523
+    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
+    bytec 7 // "implicit_key_arc4_dynamic_bytes"
+    bytec 18 // 0x000d64796e616d6963206279746573
+    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 8 // "explicit_key_arc4_uint"
+    bytec 15 // 0x0000000000000539
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:527
+    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
+    bytec 9 // "explicit_key_arc4_string"
+    bytec 16 // 0x000548656c6c6f
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:528
+    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
+    bytec 10 // "explicit_key_arc4_byte"
+    pushbytes 0x00
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:529
+    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
+    bytec 11 // "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 12 // "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 13 // "explicit_key_arc4_uint128"
+    bytec 17 // 0x00000010000000000000000000000000
+    app_global_put
+    // tests/artifacts/StateOps/contract.py:535
+    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
+    bytec 14 // "explicit_key_arc4_dynamic_bytes"
+    bytec 18 // 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_entrypoint@2:
-    // tests/artifacts/StateOps/contract.py:490
+main_after_if_else@2:
+    // tests/artifacts/StateOps/contract.py:514
     // class GlobalStateContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@34
-    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_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_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"
+    bz main_bare_routing@33
+    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 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_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_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@4 main_get_implicit_key_arc4_string_route@5 main_get_implicit_key_arc4_byte_route@6 main_get_implicit_key_arc4_bool_route@7 main_get_implicit_key_arc4_address_route@8 main_get_implicit_key_arc4_uint128_route@9 main_get_implicit_key_arc4_dynamic_bytes_route@10 main_get_arc4_uint_route@11 main_get_arc4_string_route@12 main_get_arc4_byte_route@13 main_get_arc4_bool_route@14 main_get_arc4_address_route@15 main_get_arc4_uint128_route@16 main_get_arc4_dynamic_bytes_route@17 main_set_implicit_key_arc4_uint_route@18 main_set_implicit_key_arc4_string_route@19 main_set_implicit_key_arc4_byte_route@20 main_set_implicit_key_arc4_bool_route@21 main_set_implicit_key_arc4_address_route@22 main_set_implicit_key_arc4_uint128_route@23 main_set_implicit_key_arc4_dynamic_bytes_route@24 main_set_arc4_uint_route@25 main_set_arc4_string_route@26 main_set_arc4_byte_route@27 main_set_arc4_bool_route@28 main_set_arc4_address_route@29 main_set_arc4_uint128_route@30 main_set_arc4_dynamic_bytes_route@31
-    err // reject transaction
+    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_arc4_uint_route@12 main_get_arc4_string_route@13 main_get_arc4_byte_route@14 main_get_arc4_bool_route@15 main_get_arc4_address_route@16 main_get_arc4_uint128_route@17 main_get_arc4_dynamic_bytes_route@18 main_set_implicit_key_arc4_uint_route@19 main_set_implicit_key_arc4_string_route@20 main_set_implicit_key_arc4_byte_route@21 main_set_implicit_key_arc4_bool_route@22 main_set_implicit_key_arc4_address_route@23 main_set_implicit_key_arc4_uint128_route@24 main_set_implicit_key_arc4_dynamic_bytes_route@25 main_set_arc4_uint_route@26 main_set_arc4_string_route@27 main_set_arc4_byte_route@28 main_set_arc4_bool_route@29 main_set_arc4_address_route@30 main_set_arc4_uint128_route@31 main_set_arc4_dynamic_bytes_route@32
 
-main_get_implicit_key_arc4_uint_route@4:
-    // tests/artifacts/StateOps/contract.py:514-515
-    // # Getter methods for implicit key state variables
-    // @arc4.abimethod()
-    txn OnCompletion
-    !
-    assert // OnCompletion is NoOp
-    txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_uint
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+main_after_if_else@35:
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    intc_1 // 0
     return
 
-main_get_implicit_key_arc4_string_route@5:
-    // tests/artifacts/StateOps/contract.py:519
+main_set_arc4_dynamic_bytes_route@32:
+    // tests/artifacts/StateOps/contract.py:650
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_string
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:650
+    // @arc4.abimethod()
+    callsub set_arc4_dynamic_bytes
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_byte_route@6:
-    // tests/artifacts/StateOps/contract.py:523
+main_set_arc4_uint128_route@31:
+    // tests/artifacts/StateOps/contract.py:646
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_byte
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:646
+    // @arc4.abimethod()
+    callsub set_arc4_uint128
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_bool_route@7:
-    // tests/artifacts/StateOps/contract.py:527
+main_set_arc4_address_route@30:
+    // tests/artifacts/StateOps/contract.py:642
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_bool
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:642
+    // @arc4.abimethod()
+    callsub set_arc4_address
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_address_route@8:
-    // tests/artifacts/StateOps/contract.py:531
+main_set_arc4_bool_route@29:
+    // tests/artifacts/StateOps/contract.py:638
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_address
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:638
+    // @arc4.abimethod()
+    callsub set_arc4_bool
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_uint128_route@9:
-    // tests/artifacts/StateOps/contract.py:535
+main_set_arc4_byte_route@28:
+    // tests/artifacts/StateOps/contract.py:634
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_uint128
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:634
+    // @arc4.abimethod()
+    callsub set_arc4_byte
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_dynamic_bytes_route@10:
-    // tests/artifacts/StateOps/contract.py:539
+main_set_arc4_string_route@27:
+    // tests/artifacts/StateOps/contract.py:630
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_implicit_key_arc4_dynamic_bytes
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:630
+    // @arc4.abimethod()
+    callsub set_arc4_string
+    intc_0 // 1
     return
 
-main_get_arc4_uint_route@11:
-    // tests/artifacts/StateOps/contract.py:543-544
-    // # Getter methods for explicit key state variables
+main_set_arc4_uint_route@26:
+    // tests/artifacts/StateOps/contract.py:625-626
+    // # Setter methods for explicit key state variables
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_uint
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:625-626
+    // # Setter methods for explicit key state variables
+    // @arc4.abimethod()
+    callsub set_arc4_uint
+    intc_0 // 1
     return
 
-main_get_arc4_string_route@12:
-    // tests/artifacts/StateOps/contract.py:548
+main_set_implicit_key_arc4_dynamic_bytes_route@25:
+    // tests/artifacts/StateOps/contract.py:621
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_string
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:621
+    // @arc4.abimethod()
+    callsub set_implicit_key_arc4_dynamic_bytes
+    intc_0 // 1
     return
 
-main_get_arc4_byte_route@13:
-    // tests/artifacts/StateOps/contract.py:552
+main_set_implicit_key_arc4_uint128_route@24:
+    // tests/artifacts/StateOps/contract.py:617
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_byte
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:617
+    // @arc4.abimethod()
+    callsub set_implicit_key_arc4_uint128
+    intc_0 // 1
     return
 
-main_get_arc4_bool_route@14:
-    // tests/artifacts/StateOps/contract.py:556
+main_set_implicit_key_arc4_address_route@23:
+    // tests/artifacts/StateOps/contract.py:613
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_bool
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:613
+    // @arc4.abimethod()
+    callsub set_implicit_key_arc4_address
+    intc_0 // 1
     return
 
-main_get_arc4_address_route@15:
-    // tests/artifacts/StateOps/contract.py:560
+main_set_implicit_key_arc4_bool_route@22:
+    // tests/artifacts/StateOps/contract.py:609
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_address
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:609
+    // @arc4.abimethod()
+    callsub set_implicit_key_arc4_bool
+    intc_0 // 1
     return
 
-main_get_arc4_uint128_route@16:
-    // tests/artifacts/StateOps/contract.py:564
+main_set_implicit_key_arc4_byte_route@21:
+    // tests/artifacts/StateOps/contract.py:605
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_uint128
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:605
+    // @arc4.abimethod()
+    callsub set_implicit_key_arc4_byte
+    intc_0 // 1
     return
 
-main_get_arc4_dynamic_bytes_route@17:
-    // tests/artifacts/StateOps/contract.py:568
+main_set_implicit_key_arc4_string_route@20:
+    // tests/artifacts/StateOps/contract.py:601
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    callsub get_arc4_dynamic_bytes
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
+    // class GlobalStateContract(ARC4Contract):
+    txna ApplicationArgs 1
+    // tests/artifacts/StateOps/contract.py:601
+    // @arc4.abimethod()
+    callsub set_implicit_key_arc4_string
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_uint_route@18:
-    // tests/artifacts/StateOps/contract.py:572-573
+main_set_implicit_key_arc4_uint_route@19:
+    // tests/artifacts/StateOps/contract.py:596-597
     // # Setter methods for implicit key state variables
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:514
     // class GlobalStateContract(ARC4Contract):
     txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:572-573
+    // tests/artifacts/StateOps/contract.py:596-597
     // # Setter methods for implicit key state variables
     // @arc4.abimethod()
     callsub set_implicit_key_arc4_uint
-    int 1
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_string_route@19:
-    // tests/artifacts/StateOps/contract.py:577
+main_get_arc4_dynamic_bytes_route@18:
+    // tests/artifacts/StateOps/contract.py:592
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:577
-    // @arc4.abimethod()
-    callsub set_implicit_key_arc4_string
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_dynamic_bytes
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_byte_route@20:
-    // tests/artifacts/StateOps/contract.py:581
+main_get_arc4_uint128_route@17:
+    // tests/artifacts/StateOps/contract.py:588
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:581
-    // @arc4.abimethod()
-    callsub set_implicit_key_arc4_byte
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_uint128
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_bool_route@21:
-    // tests/artifacts/StateOps/contract.py:585
+main_get_arc4_address_route@16:
+    // tests/artifacts/StateOps/contract.py:584
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:585
-    // @arc4.abimethod()
-    callsub set_implicit_key_arc4_bool
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_address
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_address_route@22:
-    // tests/artifacts/StateOps/contract.py:589
+main_get_arc4_bool_route@15:
+    // tests/artifacts/StateOps/contract.py:580
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:589
-    // @arc4.abimethod()
-    callsub set_implicit_key_arc4_address
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_bool
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_uint128_route@23:
-    // tests/artifacts/StateOps/contract.py:593
+main_get_arc4_byte_route@14:
+    // tests/artifacts/StateOps/contract.py:576
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:593
-    // @arc4.abimethod()
-    callsub set_implicit_key_arc4_uint128
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_byte
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_implicit_key_arc4_dynamic_bytes_route@24:
-    // tests/artifacts/StateOps/contract.py:597
+main_get_arc4_string_route@13:
+    // tests/artifacts/StateOps/contract.py:572
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:597
-    // @arc4.abimethod()
-    callsub set_implicit_key_arc4_dynamic_bytes
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_string
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_arc4_uint_route@25:
-    // tests/artifacts/StateOps/contract.py:601-602
-    // # Setter methods for explicit key state variables
+main_get_arc4_uint_route@12:
+    // tests/artifacts/StateOps/contract.py:567-568
+    // # Getter methods for explicit key state variables
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:601-602
-    // # Setter methods for explicit key state variables
-    // @arc4.abimethod()
-    callsub set_arc4_uint
-    int 1
+    assert // can only call when not creating
+    callsub get_arc4_uint
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_arc4_string_route@26:
-    // tests/artifacts/StateOps/contract.py:606
+main_get_implicit_key_arc4_dynamic_bytes_route@11:
+    // tests/artifacts/StateOps/contract.py:563
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:606
-    // @arc4.abimethod()
-    callsub set_arc4_string
-    int 1
+    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_set_arc4_byte_route@27:
-    // tests/artifacts/StateOps/contract.py:610
+main_get_implicit_key_arc4_uint128_route@10:
+    // tests/artifacts/StateOps/contract.py:559
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:610
-    // @arc4.abimethod()
-    callsub set_arc4_byte
-    int 1
+    assert // can only call when not creating
+    callsub get_implicit_key_arc4_uint128
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_arc4_bool_route@28:
-    // tests/artifacts/StateOps/contract.py:614
+main_get_implicit_key_arc4_address_route@9:
+    // tests/artifacts/StateOps/contract.py:555
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:614
-    // @arc4.abimethod()
-    callsub set_arc4_bool
-    int 1
+    assert // can only call when not creating
+    callsub get_implicit_key_arc4_address
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_arc4_address_route@29:
-    // tests/artifacts/StateOps/contract.py:618
+main_get_implicit_key_arc4_bool_route@8:
+    // tests/artifacts/StateOps/contract.py:551
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:618
-    // @arc4.abimethod()
-    callsub set_arc4_address
-    int 1
+    assert // can only call when not creating
+    callsub get_implicit_key_arc4_bool
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_arc4_uint128_route@30:
-    // tests/artifacts/StateOps/contract.py:622
+main_get_implicit_key_arc4_byte_route@7:
+    // tests/artifacts/StateOps/contract.py:547
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:622
-    // @arc4.abimethod()
-    callsub set_arc4_uint128
-    int 1
+    assert // can only call when not creating
+    callsub get_implicit_key_arc4_byte
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_set_arc4_dynamic_bytes_route@31:
-    // tests/artifacts/StateOps/contract.py:626
+main_get_implicit_key_arc4_string_route@6:
+    // tests/artifacts/StateOps/contract.py:543
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    txna ApplicationArgs 1
-    // tests/artifacts/StateOps/contract.py:626
+    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()
-    callsub set_arc4_dynamic_bytes
-    int 1
+    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@34:
-    // tests/artifacts/StateOps/contract.py:490
+main_bare_routing@33:
+    // tests/artifacts/StateOps/contract.py:514
     // class GlobalStateContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@35
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    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:514-516
-    // # Getter methods for implicit key state variables
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_uint(self) -> arc4.UInt64:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:517
-    // return self.implicit_key_arc4_uint.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:492-493
-    // # Implicit key state variables
-    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
-    byte "implicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:517
+    // tests/artifacts/StateOps/contract.py:541
     // return self.implicit_key_arc4_uint.value
+    intc_1 // 0
+    bytec_1 // "implicit_key_arc4_uint"
     app_global_get_ex
     assert // check self.implicit_key_arc4_uint exists
     retsub
@@ -546,18 +596,10 @@ get_implicit_key_arc4_uint:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_string() -> bytes:
 get_implicit_key_arc4_string:
-    // tests/artifacts/StateOps/contract.py:519-520
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_string(self) -> arc4.String:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:521
-    // return self.implicit_key_arc4_string.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:494
-    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
-    byte "implicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:521
+    // tests/artifacts/StateOps/contract.py:545
     // return self.implicit_key_arc4_string.value
+    intc_1 // 0
+    bytec_2 // "implicit_key_arc4_string"
     app_global_get_ex
     assert // check self.implicit_key_arc4_string exists
     retsub
@@ -565,18 +607,10 @@ get_implicit_key_arc4_string:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_byte() -> bytes:
 get_implicit_key_arc4_byte:
-    // tests/artifacts/StateOps/contract.py:523-524
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_byte(self) -> arc4.Byte:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:525
-    // return self.implicit_key_arc4_byte.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:495
-    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
-    byte "implicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:525
+    // tests/artifacts/StateOps/contract.py:549
     // return self.implicit_key_arc4_byte.value
+    intc_1 // 0
+    bytec_3 // "implicit_key_arc4_byte"
     app_global_get_ex
     assert // check self.implicit_key_arc4_byte exists
     retsub
@@ -584,18 +618,10 @@ get_implicit_key_arc4_byte:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_bool() -> bytes:
 get_implicit_key_arc4_bool:
-    // tests/artifacts/StateOps/contract.py:527-528
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_bool(self) -> arc4.Bool:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:529
-    // return self.implicit_key_arc4_bool.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:496
-    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
-    byte "implicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:529
+    // tests/artifacts/StateOps/contract.py:553
     // return self.implicit_key_arc4_bool.value
+    intc_1 // 0
+    bytec 4 // "implicit_key_arc4_bool"
     app_global_get_ex
     assert // check self.implicit_key_arc4_bool exists
     retsub
@@ -603,18 +629,10 @@ get_implicit_key_arc4_bool:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_address() -> bytes:
 get_implicit_key_arc4_address:
-    // tests/artifacts/StateOps/contract.py:531-532
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_address(self) -> arc4.Address:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:533
-    // return self.implicit_key_arc4_address.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:497
-    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
-    byte "implicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:533
+    // tests/artifacts/StateOps/contract.py:557
     // return self.implicit_key_arc4_address.value
+    intc_1 // 0
+    bytec 5 // "implicit_key_arc4_address"
     app_global_get_ex
     assert // check self.implicit_key_arc4_address exists
     retsub
@@ -622,18 +640,10 @@ get_implicit_key_arc4_address:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint128() -> bytes:
 get_implicit_key_arc4_uint128:
-    // tests/artifacts/StateOps/contract.py:535-536
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_uint128(self) -> arc4.UInt128:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:537
-    // return self.implicit_key_arc4_uint128.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:498
-    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
-    byte "implicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:537
+    // tests/artifacts/StateOps/contract.py:561
     // return self.implicit_key_arc4_uint128.value
+    intc_1 // 0
+    bytec 6 // "implicit_key_arc4_uint128"
     app_global_get_ex
     assert // check self.implicit_key_arc4_uint128 exists
     retsub
@@ -641,18 +651,10 @@ get_implicit_key_arc4_uint128:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_dynamic_bytes() -> bytes:
 get_implicit_key_arc4_dynamic_bytes:
-    // tests/artifacts/StateOps/contract.py:539-540
-    // @arc4.abimethod()
-    // def get_implicit_key_arc4_dynamic_bytes(self) -> arc4.DynamicBytes:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:541
-    // return self.implicit_key_arc4_dynamic_bytes.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:499
-    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
-    byte "implicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:541
+    // tests/artifacts/StateOps/contract.py:565
     // return self.implicit_key_arc4_dynamic_bytes.value
+    intc_1 // 0
+    bytec 7 // "implicit_key_arc4_dynamic_bytes"
     app_global_get_ex
     assert // check self.implicit_key_arc4_dynamic_bytes exists
     retsub
@@ -660,20 +662,10 @@ get_implicit_key_arc4_dynamic_bytes:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint() -> bytes:
 get_arc4_uint:
-    // tests/artifacts/StateOps/contract.py:543-545
-    // # Getter methods for explicit key state variables
-    // @arc4.abimethod()
-    // def get_arc4_uint(self) -> arc4.UInt64:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:546
-    // return self.arc4_uint.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:501-502
-    // # Explicit key state variables
-    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
-    byte "explicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:546
+    // tests/artifacts/StateOps/contract.py:570
     // return self.arc4_uint.value
+    intc_1 // 0
+    bytec 8 // "explicit_key_arc4_uint"
     app_global_get_ex
     assert // check self.arc4_uint exists
     retsub
@@ -681,18 +673,10 @@ get_arc4_uint:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_string() -> bytes:
 get_arc4_string:
-    // tests/artifacts/StateOps/contract.py:548-549
-    // @arc4.abimethod()
-    // def get_arc4_string(self) -> arc4.String:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:550
-    // return self.arc4_string.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:503
-    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
-    byte "explicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:550
+    // tests/artifacts/StateOps/contract.py:574
     // return self.arc4_string.value
+    intc_1 // 0
+    bytec 9 // "explicit_key_arc4_string"
     app_global_get_ex
     assert // check self.arc4_string exists
     retsub
@@ -700,18 +684,10 @@ get_arc4_string:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_byte() -> bytes:
 get_arc4_byte:
-    // tests/artifacts/StateOps/contract.py:552-553
-    // @arc4.abimethod()
-    // def get_arc4_byte(self) -> arc4.Byte:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:554
-    // return self.arc4_byte.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:504
-    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
-    byte "explicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:554
+    // tests/artifacts/StateOps/contract.py:578
     // return self.arc4_byte.value
+    intc_1 // 0
+    bytec 10 // "explicit_key_arc4_byte"
     app_global_get_ex
     assert // check self.arc4_byte exists
     retsub
@@ -719,18 +695,10 @@ get_arc4_byte:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_bool() -> bytes:
 get_arc4_bool:
-    // tests/artifacts/StateOps/contract.py:556-557
-    // @arc4.abimethod()
-    // def get_arc4_bool(self) -> arc4.Bool:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:558
-    // return self.arc4_bool.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:505
-    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
-    byte "explicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:558
+    // tests/artifacts/StateOps/contract.py:582
     // return self.arc4_bool.value
+    intc_1 // 0
+    bytec 11 // "explicit_key_arc4_bool"
     app_global_get_ex
     assert // check self.arc4_bool exists
     retsub
@@ -738,18 +706,10 @@ get_arc4_bool:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_address() -> bytes:
 get_arc4_address:
-    // tests/artifacts/StateOps/contract.py:560-561
-    // @arc4.abimethod()
-    // def get_arc4_address(self) -> arc4.Address:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:562
-    // return self.arc4_address.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:507
-    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
-    byte "explicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:562
+    // tests/artifacts/StateOps/contract.py:586
     // return self.arc4_address.value
+    intc_1 // 0
+    bytec 12 // "explicit_key_arc4_address"
     app_global_get_ex
     assert // check self.arc4_address exists
     retsub
@@ -757,18 +717,10 @@ get_arc4_address:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint128() -> bytes:
 get_arc4_uint128:
-    // tests/artifacts/StateOps/contract.py:564-565
-    // @arc4.abimethod()
-    // def get_arc4_uint128(self) -> arc4.UInt128:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:566
-    // return self.arc4_uint128.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:509
-    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
-    byte "explicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:566
+    // tests/artifacts/StateOps/contract.py:590
     // return self.arc4_uint128.value
+    intc_1 // 0
+    bytec 13 // "explicit_key_arc4_uint128"
     app_global_get_ex
     assert // check self.arc4_uint128 exists
     retsub
@@ -776,18 +728,10 @@ get_arc4_uint128:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_dynamic_bytes() -> bytes:
 get_arc4_dynamic_bytes:
-    // tests/artifacts/StateOps/contract.py:568-569
-    // @arc4.abimethod()
-    // def get_arc4_dynamic_bytes(self) -> arc4.DynamicBytes:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:570
-    // return self.arc4_dynamic_bytes.value
-    int 0
-    // tests/artifacts/StateOps/contract.py:511
-    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
-    byte "explicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:570
+    // tests/artifacts/StateOps/contract.py:594
     // return self.arc4_dynamic_bytes.value
+    intc_1 // 0
+    bytec 14 // "explicit_key_arc4_dynamic_bytes"
     app_global_get_ex
     assert // check self.arc4_dynamic_bytes exists
     retsub
@@ -795,17 +739,14 @@ get_arc4_dynamic_bytes:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint(value: bytes) -> void:
 set_implicit_key_arc4_uint:
-    // tests/artifacts/StateOps/contract.py:572-574
+    // tests/artifacts/StateOps/contract.py:596-598
     // # 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:492-493
-    // # Implicit key state variables
-    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
-    byte "implicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:575
+    // tests/artifacts/StateOps/contract.py:599
     // self.implicit_key_arc4_uint.value = value
+    bytec_1 // "implicit_key_arc4_uint"
     frame_dig -1
     app_global_put
     retsub
@@ -813,15 +754,13 @@ set_implicit_key_arc4_uint:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_string(value: bytes) -> void:
 set_implicit_key_arc4_string:
-    // tests/artifacts/StateOps/contract.py:577-578
+    // tests/artifacts/StateOps/contract.py:601-602
     // @arc4.abimethod()
     // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:494
-    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
-    byte "implicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:579
+    // tests/artifacts/StateOps/contract.py:603
     // self.implicit_key_arc4_string.value = value
+    bytec_2 // "implicit_key_arc4_string"
     frame_dig -1
     app_global_put
     retsub
@@ -829,15 +768,13 @@ set_implicit_key_arc4_string:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_byte(value: bytes) -> void:
 set_implicit_key_arc4_byte:
-    // tests/artifacts/StateOps/contract.py:581-582
+    // tests/artifacts/StateOps/contract.py:605-606
     // @arc4.abimethod()
     // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:495
-    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
-    byte "implicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:583
+    // tests/artifacts/StateOps/contract.py:607
     // self.implicit_key_arc4_byte.value = value
+    bytec_3 // "implicit_key_arc4_byte"
     frame_dig -1
     app_global_put
     retsub
@@ -845,15 +782,13 @@ set_implicit_key_arc4_byte:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_bool(value: bytes) -> void:
 set_implicit_key_arc4_bool:
-    // tests/artifacts/StateOps/contract.py:585-586
+    // tests/artifacts/StateOps/contract.py:609-610
     // @arc4.abimethod()
     // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:496
-    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
-    byte "implicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:587
+    // tests/artifacts/StateOps/contract.py:611
     // self.implicit_key_arc4_bool.value = value
+    bytec 4 // "implicit_key_arc4_bool"
     frame_dig -1
     app_global_put
     retsub
@@ -861,15 +796,13 @@ set_implicit_key_arc4_bool:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_address(value: bytes) -> void:
 set_implicit_key_arc4_address:
-    // tests/artifacts/StateOps/contract.py:589-590
+    // tests/artifacts/StateOps/contract.py:613-614
     // @arc4.abimethod()
     // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:497
-    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
-    byte "implicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:591
+    // tests/artifacts/StateOps/contract.py:615
     // self.implicit_key_arc4_address.value = value
+    bytec 5 // "implicit_key_arc4_address"
     frame_dig -1
     app_global_put
     retsub
@@ -877,15 +810,13 @@ set_implicit_key_arc4_address:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_implicit_key_arc4_uint128(value: bytes) -> void:
 set_implicit_key_arc4_uint128:
-    // tests/artifacts/StateOps/contract.py:593-594
+    // tests/artifacts/StateOps/contract.py:617-618
     // @arc4.abimethod()
     // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:498
-    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
-    byte "implicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:595
+    // tests/artifacts/StateOps/contract.py:619
     // self.implicit_key_arc4_uint128.value = value
+    bytec 6 // "implicit_key_arc4_uint128"
     frame_dig -1
     app_global_put
     retsub
@@ -893,15 +824,13 @@ set_implicit_key_arc4_uint128:
 
 // 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:597-598
+    // tests/artifacts/StateOps/contract.py:621-622
     // @arc4.abimethod()
     // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:499
-    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
-    byte "implicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:599
+    // tests/artifacts/StateOps/contract.py:623
     // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
+    bytec 7 // "implicit_key_arc4_dynamic_bytes"
     frame_dig -1
     app_global_put
     retsub
@@ -909,17 +838,14 @@ set_implicit_key_arc4_dynamic_bytes:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
 set_arc4_uint:
-    // tests/artifacts/StateOps/contract.py:601-603
+    // tests/artifacts/StateOps/contract.py:625-627
     // # 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:501-502
-    // # Explicit key state variables
-    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
-    byte "explicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:604
+    // tests/artifacts/StateOps/contract.py:628
     // self.arc4_uint.value = value
+    bytec 8 // "explicit_key_arc4_uint"
     frame_dig -1
     app_global_put
     retsub
@@ -927,15 +853,13 @@ set_arc4_uint:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_string(value: bytes) -> void:
 set_arc4_string:
-    // tests/artifacts/StateOps/contract.py:606-607
+    // tests/artifacts/StateOps/contract.py:630-631
     // @arc4.abimethod()
     // def set_arc4_string(self, value: arc4.String) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:503
-    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
-    byte "explicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:608
+    // tests/artifacts/StateOps/contract.py:632
     // self.arc4_string.value = value
+    bytec 9 // "explicit_key_arc4_string"
     frame_dig -1
     app_global_put
     retsub
@@ -943,15 +867,13 @@ set_arc4_string:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_byte(value: bytes) -> void:
 set_arc4_byte:
-    // tests/artifacts/StateOps/contract.py:610-611
+    // tests/artifacts/StateOps/contract.py:634-635
     // @arc4.abimethod()
     // def set_arc4_byte(self, value: arc4.Byte) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:504
-    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
-    byte "explicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:612
+    // tests/artifacts/StateOps/contract.py:636
     // self.arc4_byte.value = value
+    bytec 10 // "explicit_key_arc4_byte"
     frame_dig -1
     app_global_put
     retsub
@@ -959,15 +881,13 @@ set_arc4_byte:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_bool(value: bytes) -> void:
 set_arc4_bool:
-    // tests/artifacts/StateOps/contract.py:614-615
+    // tests/artifacts/StateOps/contract.py:638-639
     // @arc4.abimethod()
     // def set_arc4_bool(self, value: arc4.Bool) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:505
-    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
-    byte "explicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:616
+    // tests/artifacts/StateOps/contract.py:640
     // self.arc4_bool.value = value
+    bytec 11 // "explicit_key_arc4_bool"
     frame_dig -1
     app_global_put
     retsub
@@ -975,15 +895,13 @@ set_arc4_bool:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_address(value: bytes) -> void:
 set_arc4_address:
-    // tests/artifacts/StateOps/contract.py:618-619
+    // tests/artifacts/StateOps/contract.py:642-643
     // @arc4.abimethod()
     // def set_arc4_address(self, value: arc4.Address) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:507
-    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
-    byte "explicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:620
+    // tests/artifacts/StateOps/contract.py:644
     // self.arc4_address.value = value
+    bytec 12 // "explicit_key_arc4_address"
     frame_dig -1
     app_global_put
     retsub
@@ -991,15 +909,13 @@ set_arc4_address:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint128(value: bytes) -> void:
 set_arc4_uint128:
-    // tests/artifacts/StateOps/contract.py:622-623
+    // tests/artifacts/StateOps/contract.py:646-647
     // @arc4.abimethod()
     // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:509
-    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
-    byte "explicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:624
+    // tests/artifacts/StateOps/contract.py:648
     // self.arc4_uint128.value = value
+    bytec 13 // "explicit_key_arc4_uint128"
     frame_dig -1
     app_global_put
     retsub
@@ -1007,103 +923,13 @@ set_arc4_uint128:
 
 // tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_dynamic_bytes(value: bytes) -> void:
 set_arc4_dynamic_bytes:
-    // tests/artifacts/StateOps/contract.py:626-627
+    // tests/artifacts/StateOps/contract.py:650-651
     // @arc4.abimethod()
     // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:511
-    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
-    byte "explicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:628
+    // tests/artifacts/StateOps/contract.py:652
     // self.arc4_dynamic_bytes.value = value.copy()
+    bytec 14 // "explicit_key_arc4_dynamic_bytes"
     frame_dig -1
     app_global_put
     retsub
-
-
-// tests.artifacts.StateOps.contract.GlobalStateContract.__init__() -> void:
-__init__:
-    // tests/artifacts/StateOps/contract.py:491
-    // def __init__(self) -> None:
-    proto 0 0
-    // tests/artifacts/StateOps/contract.py:492-493
-    // # Implicit key state variables
-    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
-    byte "implicit_key_arc4_uint"
-    byte 0x0000000000000539
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:494
-    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
-    byte "implicit_key_arc4_string"
-    byte 0x000548656c6c6f
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:495
-    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
-    byte "implicit_key_arc4_byte"
-    byte 0x00
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:496
-    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
-    byte "implicit_key_arc4_bool"
-    byte 0x80
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:497
-    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
-    byte "implicit_key_arc4_address"
-    global CreatorAddress
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:498
-    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
-    byte "implicit_key_arc4_uint128"
-    byte 0x00000010000000000000000000000000
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:499
-    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
-    byte "implicit_key_arc4_dynamic_bytes"
-    byte 0x000d64796e616d6963206279746573
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:501-502
-    // # Explicit key state variables
-    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
-    byte "explicit_key_arc4_uint"
-    byte 0x0000000000000539
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:503
-    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
-    byte "explicit_key_arc4_string"
-    byte 0x000548656c6c6f
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:504
-    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
-    byte "explicit_key_arc4_byte"
-    byte 0x00
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:505
-    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
-    byte "explicit_key_arc4_bool"
-    byte 0x80
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:507
-    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
-    byte "explicit_key_arc4_address"
-    global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:506-508
-    // self.arc4_address = GlobalState(
-    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
-    // )
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:509
-    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
-    byte "explicit_key_arc4_uint128"
-    byte 0x00000010000000000000000000000000
-    app_global_put
-    // tests/artifacts/StateOps/contract.py:511
-    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
-    byte "explicit_key_arc4_dynamic_bytes"
-    byte 0x000d64796e616d6963206279746573
-    // tests/artifacts/StateOps/contract.py:510-512
-    // self.arc4_dynamic_bytes = GlobalState(
-    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
-    // )
-    app_global_put
-    retsub
diff --git a/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json b/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json
index 96940c8..4078b2b 100644
--- a/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json
+++ b/tests/artifacts/StateOps/data/GlobalStateContract.arc32.json
@@ -142,8 +142,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.GlobalStateContract.approval_program:
    txn ApplicationID
    bnz main_entrypoint@2
    callsub __init__

main_entrypoint@2:
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@34
    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_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_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@4 main_get_implicit_key_arc4_string_route@5 main_get_implicit_key_arc4_byte_route@6 main_get_implicit_key_arc4_bool_route@7 main_get_implicit_key_arc4_address_route@8 main_get_implicit_key_arc4_uint128_route@9 main_get_implicit_key_arc4_dynamic_bytes_route@10 main_get_arc4_uint_route@11 main_get_arc4_string_route@12 main_get_arc4_byte_route@13 main_get_arc4_bool_route@14 main_get_arc4_address_route@15 main_get_arc4_uint128_route@16 main_get_arc4_dynamic_bytes_route@17 main_set_implicit_key_arc4_uint_route@18 main_set_implicit_key_arc4_string_route@19 main_set_implicit_key_arc4_byte_route@20 main_set_implicit_key_arc4_bool_route@21 main_set_implicit_key_arc4_address_route@22 main_set_implicit_key_arc4_uint128_route@23 main_set_implicit_key_arc4_dynamic_bytes_route@24 main_set_arc4_uint_route@25 main_set_arc4_string_route@26 main_set_arc4_byte_route@27 main_set_arc4_bool_route@28 main_set_arc4_address_route@29 main_set_arc4_uint128_route@30 main_set_arc4_dynamic_bytes_route@31
    err // reject transaction

main_get_implicit_key_arc4_uint_route@4:
    // tests/artifacts/StateOps/contract.py:514-515
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_uint
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_string_route@5:
    // tests/artifacts/StateOps/contract.py:519
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_string
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_byte_route@6:
    // tests/artifacts/StateOps/contract.py:523
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_byte
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_bool_route@7:
    // tests/artifacts/StateOps/contract.py:527
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_bool
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_address_route@8:
    // tests/artifacts/StateOps/contract.py:531
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_address
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_uint128_route@9:
    // tests/artifacts/StateOps/contract.py:535
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_uint128
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@10:
    // tests/artifacts/StateOps/contract.py:539
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_implicit_key_arc4_dynamic_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_uint_route@11:
    // tests/artifacts/StateOps/contract.py:543-544
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_uint
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_string_route@12:
    // tests/artifacts/StateOps/contract.py:548
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_string
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_byte_route@13:
    // tests/artifacts/StateOps/contract.py:552
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_byte
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_bool_route@14:
    // tests/artifacts/StateOps/contract.py:556
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_bool
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_address_route@15:
    // tests/artifacts/StateOps/contract.py:560
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_address
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_uint128_route@16:
    // tests/artifacts/StateOps/contract.py:564
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_uint128
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_dynamic_bytes_route@17:
    // tests/artifacts/StateOps/contract.py:568
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub get_arc4_dynamic_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_set_implicit_key_arc4_uint_route@18:
    // tests/artifacts/StateOps/contract.py:572-573
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:572-573
    // # Setter methods for implicit key state variables
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint
    int 1
    return

main_set_implicit_key_arc4_string_route@19:
    // tests/artifacts/StateOps/contract.py:577
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:577
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_string
    int 1
    return

main_set_implicit_key_arc4_byte_route@20:
    // tests/artifacts/StateOps/contract.py:581
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:581
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_byte
    int 1
    return

main_set_implicit_key_arc4_bool_route@21:
    // tests/artifacts/StateOps/contract.py:585
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:585
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_bool
    int 1
    return

main_set_implicit_key_arc4_address_route@22:
    // tests/artifacts/StateOps/contract.py:589
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:589
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_address
    int 1
    return

main_set_implicit_key_arc4_uint128_route@23:
    // tests/artifacts/StateOps/contract.py:593
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:593
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint128
    int 1
    return

main_set_implicit_key_arc4_dynamic_bytes_route@24:
    // tests/artifacts/StateOps/contract.py:597
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:597
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_dynamic_bytes
    int 1
    return

main_set_arc4_uint_route@25:
    // tests/artifacts/StateOps/contract.py:601-602
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:601-602
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    callsub set_arc4_uint
    int 1
    return

main_set_arc4_string_route@26:
    // tests/artifacts/StateOps/contract.py:606
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:606
    // @arc4.abimethod()
    callsub set_arc4_string
    int 1
    return

main_set_arc4_byte_route@27:
    // tests/artifacts/StateOps/contract.py:610
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:610
    // @arc4.abimethod()
    callsub set_arc4_byte
    int 1
    return

main_set_arc4_bool_route@28:
    // tests/artifacts/StateOps/contract.py:614
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:614
    // @arc4.abimethod()
    callsub set_arc4_bool
    int 1
    return

main_set_arc4_address_route@29:
    // tests/artifacts/StateOps/contract.py:618
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:618
    // @arc4.abimethod()
    callsub set_arc4_address
    int 1
    return

main_set_arc4_uint128_route@30:
    // tests/artifacts/StateOps/contract.py:622
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:622
    // @arc4.abimethod()
    callsub set_arc4_uint128
    int 1
    return

main_set_arc4_dynamic_bytes_route@31:
    // tests/artifacts/StateOps/contract.py:626
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:626
    // @arc4.abimethod()
    callsub set_arc4_dynamic_bytes
    int 1
    return

main_bare_routing@34:
    // tests/artifacts/StateOps/contract.py:490
    // class GlobalStateContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.GlobalStateContract.get_implicit_key_arc4_uint() -> bytes:
get_implicit_key_arc4_uint:
    // tests/artifacts/StateOps/contract.py:514-516
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint(self) -> arc4.UInt64:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:517
    // return self.implicit_key_arc4_uint.value
    int 0
    // tests/artifacts/StateOps/contract.py:492-493
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    byte "implicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:517
    // return self.implicit_key_arc4_uint.value
    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:519-520
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self) -> arc4.String:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:521
    // return self.implicit_key_arc4_string.value
    int 0
    // tests/artifacts/StateOps/contract.py:494
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    byte "implicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:521
    // return self.implicit_key_arc4_string.value
    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:523-524
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self) -> arc4.Byte:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:525
    // return self.implicit_key_arc4_byte.value
    int 0
    // tests/artifacts/StateOps/contract.py:495
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    byte "implicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:525
    // return self.implicit_key_arc4_byte.value
    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:527-528
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self) -> arc4.Bool:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:529
    // return self.implicit_key_arc4_bool.value
    int 0
    // tests/artifacts/StateOps/contract.py:496
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    byte "implicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:529
    // return self.implicit_key_arc4_bool.value
    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:531-532
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self) -> arc4.Address:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:533
    // return self.implicit_key_arc4_address.value
    int 0
    // tests/artifacts/StateOps/contract.py:497
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    byte "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:533
    // return self.implicit_key_arc4_address.value
    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:535-536
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self) -> arc4.UInt128:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:537
    // return self.implicit_key_arc4_uint128.value
    int 0
    // tests/artifacts/StateOps/contract.py:498
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    byte "implicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:537
    // return self.implicit_key_arc4_uint128.value
    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:539-540
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self) -> arc4.DynamicBytes:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_dynamic_bytes.value
    int 0
    // tests/artifacts/StateOps/contract.py:499
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    byte "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:541
    // return self.implicit_key_arc4_dynamic_bytes.value
    app_global_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.get_arc4_uint() -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:543-545
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    // def get_arc4_uint(self) -> arc4.UInt64:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:546
    // return self.arc4_uint.value
    int 0
    // tests/artifacts/StateOps/contract.py:501-502
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    byte "explicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:546
    // return self.arc4_uint.value
    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:548-549
    // @arc4.abimethod()
    // def get_arc4_string(self) -> arc4.String:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:550
    // return self.arc4_string.value
    int 0
    // tests/artifacts/StateOps/contract.py:503
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    byte "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:550
    // return self.arc4_string.value
    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:552-553
    // @arc4.abimethod()
    // def get_arc4_byte(self) -> arc4.Byte:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:554
    // return self.arc4_byte.value
    int 0
    // tests/artifacts/StateOps/contract.py:504
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    byte "explicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:554
    // return self.arc4_byte.value
    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:556-557
    // @arc4.abimethod()
    // def get_arc4_bool(self) -> arc4.Bool:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:558
    // return self.arc4_bool.value
    int 0
    // tests/artifacts/StateOps/contract.py:505
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    byte "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:558
    // return self.arc4_bool.value
    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:560-561
    // @arc4.abimethod()
    // def get_arc4_address(self) -> arc4.Address:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:562
    // return self.arc4_address.value
    int 0
    // tests/artifacts/StateOps/contract.py:507
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    byte "explicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:562
    // return self.arc4_address.value
    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:564-565
    // @arc4.abimethod()
    // def get_arc4_uint128(self) -> arc4.UInt128:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:566
    // return self.arc4_uint128.value
    int 0
    // tests/artifacts/StateOps/contract.py:509
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    byte "explicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:566
    // return self.arc4_uint128.value
    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:568-569
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self) -> arc4.DynamicBytes:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:570
    // return self.arc4_dynamic_bytes.value
    int 0
    // tests/artifacts/StateOps/contract.py:511
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    byte "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:570
    // return self.arc4_dynamic_bytes.value
    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:572-574
    // # 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:492-493
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    byte "implicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:575
    // self.implicit_key_arc4_uint.value = value
    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:577-578
    // @arc4.abimethod()
    // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:494
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    byte "implicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:579
    // self.implicit_key_arc4_string.value = value
    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:581-582
    // @arc4.abimethod()
    // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:495
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    byte "implicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:583
    // self.implicit_key_arc4_byte.value = value
    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:585-586
    // @arc4.abimethod()
    // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:496
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    byte "implicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:587
    // self.implicit_key_arc4_bool.value = value
    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:589-590
    // @arc4.abimethod()
    // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:497
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    byte "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:591
    // self.implicit_key_arc4_address.value = value
    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:593-594
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:498
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    byte "implicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:595
    // self.implicit_key_arc4_uint128.value = value
    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:597-598
    // @arc4.abimethod()
    // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:499
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    byte "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:599
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:601-603
    // # 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:501-502
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    byte "explicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:604
    // self.arc4_uint.value = value
    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:606-607
    // @arc4.abimethod()
    // def set_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:503
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    byte "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:608
    // self.arc4_string.value = value
    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:610-611
    // @arc4.abimethod()
    // def set_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:504
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    byte "explicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:612
    // self.arc4_byte.value = value
    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:614-615
    // @arc4.abimethod()
    // def set_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:505
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    byte "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:616
    // self.arc4_bool.value = value
    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:618-619
    // @arc4.abimethod()
    // def set_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:507
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    byte "explicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:620
    // self.arc4_address.value = value
    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:622-623
    // @arc4.abimethod()
    // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:509
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    byte "explicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:624
    // self.arc4_uint128.value = value
    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:626-627
    // @arc4.abimethod()
    // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:511
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    byte "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:628
    // self.arc4_dynamic_bytes.value = value.copy()
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.__init__() -> void:
__init__:
    // tests/artifacts/StateOps/contract.py:491
    // def __init__(self) -> None:
    proto 0 0
    // tests/artifacts/StateOps/contract.py:492-493
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    byte "implicit_key_arc4_uint"
    byte 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:494
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    byte "implicit_key_arc4_string"
    byte 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:495
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    byte "implicit_key_arc4_byte"
    byte 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:496
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    byte "implicit_key_arc4_bool"
    byte 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:497
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    byte "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:498
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    byte "implicit_key_arc4_uint128"
    byte 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:499
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    byte "implicit_key_arc4_dynamic_bytes"
    byte 0x000d64796e616d6963206279746573
    app_global_put
    // tests/artifacts/StateOps/contract.py:501-502
    // # Explicit key state variables
    // self.arc4_uint = GlobalState(arc4.UInt64(1337), key="explicit_key_arc4_uint")
    byte "explicit_key_arc4_uint"
    byte 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:503
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    byte "explicit_key_arc4_string"
    byte 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:504
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    byte "explicit_key_arc4_byte"
    byte 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:505
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    byte "explicit_key_arc4_bool"
    byte 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:507
    // arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    byte "explicit_key_arc4_address"
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:506-508
    // self.arc4_address = GlobalState(
    //     arc4.Address(Global.creator_address), key="explicit_key_arc4_address"
    // )
    app_global_put
    // tests/artifacts/StateOps/contract.py:509
    // self.arc4_uint128 = GlobalState(arc4.UInt128(2**100), key="explicit_key_arc4_uint128")
    byte "explicit_key_arc4_uint128"
    byte 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:511
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    byte "explicit_key_arc4_dynamic_bytes"
    byte 0x000d64796e616d6963206279746573
    // tests/artifacts/StateOps/contract.py:510-512
    // self.arc4_dynamic_bytes = GlobalState(
    //     arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    // )
    app_global_put
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuR2xvYmFsU3RhdGVDb250cmFjdC5jbGVhcl9zdGF0ZV9wcm9ncmFtOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ5MAogICAgLy8gY2xhc3MgR2xvYmFsU3RhdGVDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.GlobalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 "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" "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
    txn ApplicationID
    bnz main_after_if_else@2
    // tests/artifacts/StateOps/contract.py:516-517
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = GlobalState(arc4.UInt64(1337))
    bytec_1 // "implicit_key_arc4_uint"
    bytec 15 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:518
    // self.implicit_key_arc4_string = GlobalState(arc4.String("Hello"))
    bytec_2 // "implicit_key_arc4_string"
    bytec 16 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:519
    // self.implicit_key_arc4_byte = GlobalState(arc4.Byte(0))
    bytec_3 // "implicit_key_arc4_byte"
    pushbytes 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:520
    // self.implicit_key_arc4_bool = GlobalState(arc4.Bool(True))
    bytec 4 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_global_put
    // tests/artifacts/StateOps/contract.py:521
    // self.implicit_key_arc4_address = GlobalState(arc4.Address(Global.creator_address))
    bytec 5 // "implicit_key_arc4_address"
    global CreatorAddress
    app_global_put
    // tests/artifacts/StateOps/contract.py:522
    // self.implicit_key_arc4_uint128 = GlobalState(arc4.UInt128(2**100))
    bytec 6 // "implicit_key_arc4_uint128"
    bytec 17 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:523
    // self.implicit_key_arc4_dynamic_bytes = GlobalState(arc4.DynamicBytes(b"dynamic bytes"))
    bytec 7 // "implicit_key_arc4_dynamic_bytes"
    bytec 18 // 0x000d64796e616d6963206279746573
    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 8 // "explicit_key_arc4_uint"
    bytec 15 // 0x0000000000000539
    app_global_put
    // tests/artifacts/StateOps/contract.py:527
    // self.arc4_string = GlobalState(arc4.String("Hello"), key="explicit_key_arc4_string")
    bytec 9 // "explicit_key_arc4_string"
    bytec 16 // 0x000548656c6c6f
    app_global_put
    // tests/artifacts/StateOps/contract.py:528
    // self.arc4_byte = GlobalState(arc4.Byte(0), key="explicit_key_arc4_byte")
    bytec 10 // "explicit_key_arc4_byte"
    pushbytes 0x00
    app_global_put
    // tests/artifacts/StateOps/contract.py:529
    // self.arc4_bool = GlobalState(arc4.Bool(True), key="explicit_key_arc4_bool")
    bytec 11 // "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 12 // "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 13 // "explicit_key_arc4_uint128"
    bytec 17 // 0x00000010000000000000000000000000
    app_global_put
    // tests/artifacts/StateOps/contract.py:535
    // arc4.DynamicBytes(b"dynamic bytes"), key="explicit_key_arc4_dynamic_bytes"
    bytec 14 // "explicit_key_arc4_dynamic_bytes"
    bytec 18 // 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:514
    // class GlobalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@33
    pushbytess 0x1cc966ee 0x2367cd4b 0x69128e90 0x68d590e2 0x44ef0681 0x1cd294ec 0xaac8ecb1 0x3cc3bb7b 0x9a6946ad 0xded75033 0x66279e93 0x096e927b 0x97531fbc 0x6ea3f996 0xa7f4f402 0xaaddcc4c 0x5ec3116d 0x20f56eee 0x1c149a43 0xa575ac7d 0x87f0869b 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_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_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_arc4_uint_route@12 main_get_arc4_string_route@13 main_get_arc4_byte_route@14 main_get_arc4_bool_route@15 main_get_arc4_address_route@16 main_get_arc4_uint128_route@17 main_get_arc4_dynamic_bytes_route@18 main_set_implicit_key_arc4_uint_route@19 main_set_implicit_key_arc4_string_route@20 main_set_implicit_key_arc4_byte_route@21 main_set_implicit_key_arc4_bool_route@22 main_set_implicit_key_arc4_address_route@23 main_set_implicit_key_arc4_uint128_route@24 main_set_implicit_key_arc4_dynamic_bytes_route@25 main_set_arc4_uint_route@26 main_set_arc4_string_route@27 main_set_arc4_byte_route@28 main_set_arc4_bool_route@29 main_set_arc4_address_route@30 main_set_arc4_uint128_route@31 main_set_arc4_dynamic_bytes_route@32

main_after_if_else@35:
    // tests/artifacts/StateOps/contract.py:514
    // class GlobalStateContract(ARC4Contract):
    intc_1 // 0
    return

main_set_arc4_dynamic_bytes_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:650
    // @arc4.abimethod()
    callsub set_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_arc4_uint128_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:646
    // @arc4.abimethod()
    callsub set_arc4_uint128
    intc_0 // 1
    return

main_set_arc4_address_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:642
    // @arc4.abimethod()
    callsub set_arc4_address
    intc_0 // 1
    return

main_set_arc4_bool_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:638
    // @arc4.abimethod()
    callsub set_arc4_bool
    intc_0 // 1
    return

main_set_arc4_byte_route@28:
    // tests/artifacts/StateOps/contract.py:634
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:634
    // @arc4.abimethod()
    callsub set_arc4_byte
    intc_0 // 1
    return

main_set_arc4_string_route@27:
    // tests/artifacts/StateOps/contract.py:630
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:630
    // @arc4.abimethod()
    callsub set_arc4_string
    intc_0 // 1
    return

main_set_arc4_uint_route@26:
    // tests/artifacts/StateOps/contract.py:625-626
    // # 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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:625-626
    // # Setter methods for explicit key state variables
    // @arc4.abimethod()
    callsub set_arc4_uint
    intc_0 // 1
    return

main_set_implicit_key_arc4_dynamic_bytes_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:621
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_dynamic_bytes
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint128_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:617
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_uint128
    intc_0 // 1
    return

main_set_implicit_key_arc4_address_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:613
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_address
    intc_0 // 1
    return

main_set_implicit_key_arc4_bool_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:609
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_bool
    intc_0 // 1
    return

main_set_implicit_key_arc4_byte_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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:605
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_byte
    intc_0 // 1
    return

main_set_implicit_key_arc4_string_route@20:
    // tests/artifacts/StateOps/contract.py:601
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:601
    // @arc4.abimethod()
    callsub set_implicit_key_arc4_string
    intc_0 // 1
    return

main_set_implicit_key_arc4_uint_route@19:
    // tests/artifacts/StateOps/contract.py:596-597
    // # 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:514
    // class GlobalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    // tests/artifacts/StateOps/contract.py:596-597
    // # 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@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_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_uint128_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_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_address_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_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_bool_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_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_byte_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_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_arc4_string_route@13:
    // tests/artifacts/StateOps/contract.py:572
    // @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@12:
    // tests/artifacts/StateOps/contract.py:567-568
    // # 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_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@33:
    // tests/artifacts/StateOps/contract.py:514
    // class GlobalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@35
    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_1 // "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_2 // "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_3 // "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 4 // "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 5 // "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 6 // "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 7 // "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_arc4_uint() -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:570
    // return self.arc4_uint.value
    intc_1 // 0
    bytec 8 // "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:574
    // return self.arc4_string.value
    intc_1 // 0
    bytec 9 // "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:578
    // return self.arc4_byte.value
    intc_1 // 0
    bytec 10 // "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:582
    // return self.arc4_bool.value
    intc_1 // 0
    bytec 11 // "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:586
    // return self.arc4_address.value
    intc_1 // 0
    bytec 12 // "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:590
    // return self.arc4_uint128.value
    intc_1 // 0
    bytec 13 // "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:594
    // return self.arc4_dynamic_bytes.value
    intc_1 // 0
    bytec 14 // "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:596-598
    // # 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:599
    // self.implicit_key_arc4_uint.value = value
    bytec_1 // "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:601-602
    // @arc4.abimethod()
    // def set_implicit_key_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:603
    // self.implicit_key_arc4_string.value = value
    bytec_2 // "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:605-606
    // @arc4.abimethod()
    // def set_implicit_key_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:607
    // self.implicit_key_arc4_byte.value = value
    bytec_3 // "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:609-610
    // @arc4.abimethod()
    // def set_implicit_key_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:611
    // self.implicit_key_arc4_bool.value = value
    bytec 4 // "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:613-614
    // @arc4.abimethod()
    // def set_implicit_key_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:615
    // self.implicit_key_arc4_address.value = value
    bytec 5 // "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:617-618
    // @arc4.abimethod()
    // def set_implicit_key_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:619
    // self.implicit_key_arc4_uint128.value = value
    bytec 6 // "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:621-622
    // @arc4.abimethod()
    // def set_implicit_key_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:623
    // self.implicit_key_arc4_dynamic_bytes.value = value.copy()
    bytec 7 // "implicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.GlobalStateContract.set_arc4_uint(value: bytes) -> void:
set_arc4_uint:
    // tests/artifacts/StateOps/contract.py:625-627
    // # 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:628
    // self.arc4_uint.value = value
    bytec 8 // "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:630-631
    // @arc4.abimethod()
    // def set_arc4_string(self, value: arc4.String) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:632
    // self.arc4_string.value = value
    bytec 9 // "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:634-635
    // @arc4.abimethod()
    // def set_arc4_byte(self, value: arc4.Byte) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:636
    // self.arc4_byte.value = value
    bytec 10 // "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:638-639
    // @arc4.abimethod()
    // def set_arc4_bool(self, value: arc4.Bool) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:640
    // self.arc4_bool.value = value
    bytec 11 // "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:642-643
    // @arc4.abimethod()
    // def set_arc4_address(self, value: arc4.Address) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_address.value = value
    bytec 12 // "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:646-647
    // @arc4.abimethod()
    // def set_arc4_uint128(self, value: arc4.UInt128) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_uint128.value = value
    bytec 13 // "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:650-651
    // @arc4.abimethod()
    // def set_arc4_dynamic_bytes(self, value: arc4.DynamicBytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:652
    // self.arc4_dynamic_bytes.value = value.copy()
    bytec 14 // "explicit_key_arc4_dynamic_bytes"
    frame_dig -1
    app_global_put
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/GlobalStateContract.clear.teal b/tests/artifacts/StateOps/data/GlobalStateContract.clear.teal
index af34e74..a433105 100644
--- a/tests/artifacts/StateOps/data/GlobalStateContract.clear.teal
+++ b/tests/artifacts/StateOps/data/GlobalStateContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.GlobalStateContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:490
-    // class GlobalStateContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/ITxnOpsContract.approval.teal b/tests/artifacts/StateOps/data/ITxnOpsContract.approval.teal
index a89c352..54c28e2 100644
--- a/tests/artifacts/StateOps/data/ITxnOpsContract.approval.teal
+++ b/tests/artifacts/StateOps/data/ITxnOpsContract.approval.teal
@@ -1,120 +1,124 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.ITxnOpsContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:465
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1 6 1000
+    bytecblock 0x068101
+    // tests/artifacts/StateOps/contract.py:489
     // class ITxnOpsContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@5
-    method "verify_itxn_ops()void"
+    bz main_bare_routing@6
+    pushbytes 0x4e7cd9cb // method "verify_itxn_ops()void"
     txna ApplicationArgs 0
-    match main_verify_itxn_ops_route@2
-    err // reject transaction
+    match main_verify_itxn_ops_route@3
 
-main_verify_itxn_ops_route@2:
-    // tests/artifacts/StateOps/contract.py:466
+main_after_if_else@10:
+    // tests/artifacts/StateOps/contract.py:489
+    // class ITxnOpsContract(ARC4Contract):
+    pushint 0 // 0
+    return
+
+main_verify_itxn_ops_route@3:
+    // tests/artifacts/StateOps/contract.py:490
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     callsub verify_itxn_ops
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@5:
-    // tests/artifacts/StateOps/contract.py:465
+main_bare_routing@6:
+    // tests/artifacts/StateOps/contract.py:489
     // class ITxnOpsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@10
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.ITxnOpsContract.verify_itxn_ops() -> void:
 verify_itxn_ops:
-    // tests/artifacts/StateOps/contract.py:466-467
-    // @arc4.abimethod()
-    // def verify_itxn_ops(self) -> None:
-    proto 0 0
-    // tests/artifacts/StateOps/contract.py:468
+    // tests/artifacts/StateOps/contract.py:492
     // algopy.op.ITxnCreate.begin()
     itxn_begin
-    // tests/artifacts/StateOps/contract.py:469
+    // tests/artifacts/StateOps/contract.py:493
     // algopy.op.ITxnCreate.set_type_enum(algopy.TransactionType.ApplicationCall)
-    int appl
+    intc_1 // appl
     itxn_field TypeEnum
-    // tests/artifacts/StateOps/contract.py:470
+    // tests/artifacts/StateOps/contract.py:494
     // algopy.op.ITxnCreate.set_on_completion(algopy.OnCompleteAction.DeleteApplication)
-    int DeleteApplication
+    pushint 5 // DeleteApplication
     itxn_field OnCompletion
-    // tests/artifacts/StateOps/contract.py:471
+    // tests/artifacts/StateOps/contract.py:495
     // algopy.op.ITxnCreate.set_approval_program(Bytes.from_hex("068101"))
-    byte 0x068101
+    bytec_0 // 0x068101
     itxn_field ApprovalProgram
-    // tests/artifacts/StateOps/contract.py:472-473
+    // tests/artifacts/StateOps/contract.py:496-497
     // # pages essentially appends
     // algopy.op.ITxnCreate.set_approval_program_pages(Bytes.from_hex("068101"))
-    byte 0x068101
+    bytec_0 // 0x068101
     itxn_field ApprovalProgramPages
-    // tests/artifacts/StateOps/contract.py:474
+    // tests/artifacts/StateOps/contract.py:498
     // algopy.op.ITxnCreate.set_clear_state_program(Bytes.from_hex("068101"))
-    byte 0x068101
+    bytec_0 // 0x068101
     itxn_field ClearStateProgram
-    // tests/artifacts/StateOps/contract.py:475
+    // tests/artifacts/StateOps/contract.py:499
     // algopy.op.ITxnCreate.set_fee(algopy.op.Global.min_txn_fee)
     global MinTxnFee
     itxn_field Fee
-    // tests/artifacts/StateOps/contract.py:476
+    // tests/artifacts/StateOps/contract.py:500
     // algopy.op.ITxnCreate.next()
     itxn_next
-    // tests/artifacts/StateOps/contract.py:477
+    // tests/artifacts/StateOps/contract.py:501
     // algopy.op.ITxnCreate.set_type_enum(algopy.TransactionType.Payment)
-    int pay
+    intc_0 // pay
     itxn_field TypeEnum
-    // tests/artifacts/StateOps/contract.py:478
+    // tests/artifacts/StateOps/contract.py:502
     // algopy.op.ITxnCreate.set_receiver(algopy.op.Global.creator_address)
     global CreatorAddress
     itxn_field Receiver
-    // tests/artifacts/StateOps/contract.py:479
+    // tests/artifacts/StateOps/contract.py:503
     // algopy.op.ITxnCreate.set_amount(algopy.UInt64(1000))
-    int 1000
+    intc_2 // 1000
     itxn_field Amount
-    // tests/artifacts/StateOps/contract.py:480
+    // tests/artifacts/StateOps/contract.py:504
     // algopy.op.ITxnCreate.submit()
     itxn_submit
-    // tests/artifacts/StateOps/contract.py:482
+    // tests/artifacts/StateOps/contract.py:506
     // assert algopy.op.ITxn.receiver() == algopy.op.Global.creator_address
     itxn Receiver
     global CreatorAddress
     ==
     assert
-    // tests/artifacts/StateOps/contract.py:483
+    // tests/artifacts/StateOps/contract.py:507
     // assert algopy.op.ITxn.amount() == algopy.UInt64(1000)
     itxn Amount
-    int 1000
+    intc_2 // 1000
     ==
     assert
-    // tests/artifacts/StateOps/contract.py:484
+    // tests/artifacts/StateOps/contract.py:508
     // assert algopy.op.ITxn.type_enum() == algopy.TransactionType.Payment
     itxn TypeEnum
-    int pay
+    intc_0 // pay
     ==
     assert
-    // tests/artifacts/StateOps/contract.py:486
+    // tests/artifacts/StateOps/contract.py:510
     // assert algopy.op.GITxn.type_enum(0) == algopy.TransactionType.ApplicationCall
     gitxn 0 TypeEnum
-    int appl
+    intc_1 // appl
     ==
     assert
-    // tests/artifacts/StateOps/contract.py:487
+    // tests/artifacts/StateOps/contract.py:511
     // assert algopy.op.GITxn.type_enum(1) == algopy.TransactionType.Payment
     gitxn 1 TypeEnum
-    int pay
+    intc_0 // pay
     ==
     assert
     retsub
diff --git a/tests/artifacts/StateOps/data/ITxnOpsContract.arc32.json b/tests/artifacts/StateOps/data/ITxnOpsContract.arc32.json
index d42ec09..dd60e45 100644
--- a/tests/artifacts/StateOps/data/ITxnOpsContract.arc32.json
+++ b/tests/artifacts/StateOps/data/ITxnOpsContract.arc32.json
@@ -7,8 +7,8 @@
         }
     },
     "source": {
-        "approval": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuSVR4bk9wc0NvbnRyYWN0LmFwcHJvdmFsX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY1CiAgICAvLyBjbGFzcyBJVHhuT3BzQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIHR4biBOdW1BcHBBcmdzCiAgICBieiBtYWluX2JhcmVfcm91dGluZ0A1CiAgICBtZXRob2QgInZlcmlmeV9pdHhuX29wcygpdm9pZCIKICAgIHR4bmEgQXBwbGljYXRpb25BcmdzIDAKICAgIG1hdGNoIG1haW5fdmVyaWZ5X2l0eG5fb3BzX3JvdXRlQDIKICAgIGVyciAvLyByZWplY3QgdHJhbnNhY3Rpb24KCm1haW5fdmVyaWZ5X2l0eG5fb3BzX3JvdXRlQDI6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY2CiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgIQogICAgYXNzZXJ0IC8vIE9uQ29tcGxldGlvbiBpcyBOb09wCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgYXNzZXJ0IC8vIGlzIG5vdCBjcmVhdGluZwogICAgY2FsbHN1YiB2ZXJpZnlfaXR4bl9vcHMKICAgIGludCAxCiAgICByZXR1cm4KCm1haW5fYmFyZV9yb3V0aW5nQDU6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY1CiAgICAvLyBjbGFzcyBJVHhuT3BzQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIGFzc2VydCAvLyByZWplY3QgdHJhbnNhY3Rpb24KICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAhCiAgICBhc3NlcnQgLy8gaXMgY3JlYXRpbmcKICAgIGludCAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuSVR4bk9wc0NvbnRyYWN0LnZlcmlmeV9pdHhuX29wcygpIC0+IHZvaWQ6CnZlcmlmeV9pdHhuX29wczoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NjYtNDY3CiAgICAvLyBAYXJjNC5hYmltZXRob2QoKQogICAgLy8gZGVmIHZlcmlmeV9pdHhuX29wcyhzZWxmKSAtPiBOb25lOgogICAgcHJvdG8gMCAwCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY4CiAgICAvLyBhbGdvcHkub3AuSVR4bkNyZWF0ZS5iZWdpbigpCiAgICBpdHhuX2JlZ2luCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY5CiAgICAvLyBhbGdvcHkub3AuSVR4bkNyZWF0ZS5zZXRfdHlwZV9lbnVtKGFsZ29weS5UcmFuc2FjdGlvblR5cGUuQXBwbGljYXRpb25DYWxsKQogICAgaW50IGFwcGwKICAgIGl0eG5fZmllbGQgVHlwZUVudW0KICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NzAKICAgIC8vIGFsZ29weS5vcC5JVHhuQ3JlYXRlLnNldF9vbl9jb21wbGV0aW9uKGFsZ29weS5PbkNvbXBsZXRlQWN0aW9uLkRlbGV0ZUFwcGxpY2F0aW9uKQogICAgaW50IERlbGV0ZUFwcGxpY2F0aW9uCiAgICBpdHhuX2ZpZWxkIE9uQ29tcGxldGlvbgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3MQogICAgLy8gYWxnb3B5Lm9wLklUeG5DcmVhdGUuc2V0X2FwcHJvdmFsX3Byb2dyYW0oQnl0ZXMuZnJvbV9oZXgoIjA2ODEwMSIpKQogICAgYnl0ZSAweDA2ODEwMQogICAgaXR4bl9maWVsZCBBcHByb3ZhbFByb2dyYW0KICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NzItNDczCiAgICAvLyAjIHBhZ2VzIGVzc2VudGlhbGx5IGFwcGVuZHMKICAgIC8vIGFsZ29weS5vcC5JVHhuQ3JlYXRlLnNldF9hcHByb3ZhbF9wcm9ncmFtX3BhZ2VzKEJ5dGVzLmZyb21faGV4KCIwNjgxMDEiKSkKICAgIGJ5dGUgMHgwNjgxMDEKICAgIGl0eG5fZmllbGQgQXBwcm92YWxQcm9ncmFtUGFnZXMKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NzQKICAgIC8vIGFsZ29weS5vcC5JVHhuQ3JlYXRlLnNldF9jbGVhcl9zdGF0ZV9wcm9ncmFtKEJ5dGVzLmZyb21faGV4KCIwNjgxMDEiKSkKICAgIGJ5dGUgMHgwNjgxMDEKICAgIGl0eG5fZmllbGQgQ2xlYXJTdGF0ZVByb2dyYW0KICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NzUKICAgIC8vIGFsZ29weS5vcC5JVHhuQ3JlYXRlLnNldF9mZWUoYWxnb3B5Lm9wLkdsb2JhbC5taW5fdHhuX2ZlZSkKICAgIGdsb2JhbCBNaW5UeG5GZWUKICAgIGl0eG5fZmllbGQgRmVlCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDc2CiAgICAvLyBhbGdvcHkub3AuSVR4bkNyZWF0ZS5uZXh0KCkKICAgIGl0eG5fbmV4dAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ3NwogICAgLy8gYWxnb3B5Lm9wLklUeG5DcmVhdGUuc2V0X3R5cGVfZW51bShhbGdvcHkuVHJhbnNhY3Rpb25UeXBlLlBheW1lbnQpCiAgICBpbnQgcGF5CiAgICBpdHhuX2ZpZWxkIFR5cGVFbnVtCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDc4CiAgICAvLyBhbGdvcHkub3AuSVR4bkNyZWF0ZS5zZXRfcmVjZWl2ZXIoYWxnb3B5Lm9wLkdsb2JhbC5jcmVhdG9yX2FkZHJlc3MpCiAgICBnbG9iYWwgQ3JlYXRvckFkZHJlc3MKICAgIGl0eG5fZmllbGQgUmVjZWl2ZXIKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0NzkKICAgIC8vIGFsZ29weS5vcC5JVHhuQ3JlYXRlLnNldF9hbW91bnQoYWxnb3B5LlVJbnQ2NCgxMDAwKSkKICAgIGludCAxMDAwCiAgICBpdHhuX2ZpZWxkIEFtb3VudAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQ4MAogICAgLy8gYWxnb3B5Lm9wLklUeG5DcmVhdGUuc3VibWl0KCkKICAgIGl0eG5fc3VibWl0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDgyCiAgICAvLyBhc3NlcnQgYWxnb3B5Lm9wLklUeG4ucmVjZWl2ZXIoKSA9PSBhbGdvcHkub3AuR2xvYmFsLmNyZWF0b3JfYWRkcmVzcwogICAgaXR4biBSZWNlaXZlcgogICAgZ2xvYmFsIENyZWF0b3JBZGRyZXNzCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDgzCiAgICAvLyBhc3NlcnQgYWxnb3B5Lm9wLklUeG4uYW1vdW50KCkgPT0gYWxnb3B5LlVJbnQ2NCgxMDAwKQogICAgaXR4biBBbW91bnQKICAgIGludCAxMDAwCiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDg0CiAgICAvLyBhc3NlcnQgYWxnb3B5Lm9wLklUeG4udHlwZV9lbnVtKCkgPT0gYWxnb3B5LlRyYW5zYWN0aW9uVHlwZS5QYXltZW50CiAgICBpdHhuIFR5cGVFbnVtCiAgICBpbnQgcGF5CiAgICA9PQogICAgYXNzZXJ0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDg2CiAgICAvLyBhc3NlcnQgYWxnb3B5Lm9wLkdJVHhuLnR5cGVfZW51bSgwKSA9PSBhbGdvcHkuVHJhbnNhY3Rpb25UeXBlLkFwcGxpY2F0aW9uQ2FsbAogICAgZ2l0eG4gMCBUeXBlRW51bQogICAgaW50IGFwcGwKICAgID09CiAgICBhc3NlcnQKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTo0ODcKICAgIC8vIGFzc2VydCBhbGdvcHkub3AuR0lUeG4udHlwZV9lbnVtKDEpID09IGFsZ29weS5UcmFuc2FjdGlvblR5cGUuUGF5bWVudAogICAgZ2l0eG4gMSBUeXBlRW51bQogICAgaW50IHBheQogICAgPT0KICAgIGFzc2VydAogICAgcmV0c3ViCg==",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuSVR4bk9wc0NvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDY1CiAgICAvLyBjbGFzcyBJVHhuT3BzQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/ITxnOpsContract.clear.teal b/tests/artifacts/StateOps/data/ITxnOpsContract.clear.teal
index 69aa389..a433105 100644
--- a/tests/artifacts/StateOps/data/ITxnOpsContract.clear.teal
+++ b/tests/artifacts/StateOps/data/ITxnOpsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.ITxnOpsContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:465
-    // class ITxnOpsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/LocalStateContract.approval.teal b/tests/artifacts/StateOps/data/LocalStateContract.approval.teal
index d00de63..8676726 100644
--- a/tests/artifacts/StateOps/data/LocalStateContract.approval.teal
+++ b/tests/artifacts/StateOps/data/LocalStateContract.approval.teal
@@ -1,555 +1,486 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.LocalStateContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:631
+// tests.artifacts.StateOps.contract.LocalStateContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75 "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 "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:655
     // class LocalStateContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@19
-    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_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[]"
+    bz main_bare_routing@20
+    pushbytess 0x30c6d58a 0x2284b7af 0x26b45756 0xecf633b0 0x3e531223 0x3ed6799d 0x5296d5ca 0x676a87c2 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_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@2 main_get_implicit_key_arc4_uint_route@3 main_get_implicit_key_arc4_string_route@4 main_get_implicit_key_arc4_byte_route@5 main_get_implicit_key_arc4_bool_route@6 main_get_implicit_key_arc4_address_route@7 main_get_implicit_key_arc4_uint128_route@8 main_get_implicit_key_arc4_dynamic_bytes_route@9 main_get_arc4_uint_route@10 main_get_arc4_string_route@11 main_get_arc4_byte_route@12 main_get_arc4_bool_route@13 main_get_arc4_address_route@14 main_get_arc4_uint128_route@15 main_get_arc4_dynamic_bytes_route@16
-    err // reject transaction
+    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_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_opt_in_route@2:
-    // tests/artifacts/StateOps/contract.py:653
-    // @arc4.abimethod(allow_actions=["OptIn"])
-    txn OnCompletion
-    int OptIn
-    ==
-    assert // OnCompletion is OptIn
-    txn ApplicationID
-    assert // is not creating
-    callsub opt_in
-    int 1
+main_after_if_else@22:
+    // tests/artifacts/StateOps/contract.py:655
+    // class LocalStateContract(ARC4Contract):
+    intc_1 // 0
     return
 
-main_get_implicit_key_arc4_uint_route@3:
-    // tests/artifacts/StateOps/contract.py:675-676
-    // # Getter methods for implicit key state variables
+main_get_arc4_dynamic_bytes_route@19:
+    // tests/artifacts/StateOps/contract.py:753
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:675-676
-    // # Getter methods for implicit key state variables
+    // tests/artifacts/StateOps/contract.py:753
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_uint
-    byte 0x151f7c75
+    callsub get_arc4_dynamic_bytes
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_string_route@4:
-    // tests/artifacts/StateOps/contract.py:680
+main_get_arc4_uint128_route@18:
+    // tests/artifacts/StateOps/contract.py:749
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:680
+    // tests/artifacts/StateOps/contract.py:749
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_string
-    byte 0x151f7c75
+    callsub get_arc4_uint128
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_byte_route@5:
-    // tests/artifacts/StateOps/contract.py:684
+main_get_arc4_address_route@17:
+    // tests/artifacts/StateOps/contract.py:745
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:684
+    // tests/artifacts/StateOps/contract.py:745
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_byte
-    byte 0x151f7c75
+    callsub get_arc4_address
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_bool_route@6:
-    // tests/artifacts/StateOps/contract.py:688
+main_get_arc4_bool_route@16:
+    // tests/artifacts/StateOps/contract.py:741
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:688
+    // tests/artifacts/StateOps/contract.py:741
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_bool
-    byte 0x151f7c75
+    callsub get_arc4_bool
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_address_route@7:
-    // tests/artifacts/StateOps/contract.py:692
+main_get_arc4_byte_route@15:
+    // tests/artifacts/StateOps/contract.py:737
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:692
+    // tests/artifacts/StateOps/contract.py:737
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_address
-    byte 0x151f7c75
+    callsub get_arc4_byte
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_uint128_route@8:
-    // tests/artifacts/StateOps/contract.py:696
+main_get_arc4_string_route@14:
+    // tests/artifacts/StateOps/contract.py:733
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:696
+    // tests/artifacts/StateOps/contract.py:733
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_uint128
-    byte 0x151f7c75
+    callsub get_arc4_string
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_implicit_key_arc4_dynamic_bytes_route@9:
-    // tests/artifacts/StateOps/contract.py:700
+main_get_arc4_uint_route@13:
+    // tests/artifacts/StateOps/contract.py:728-729
+    // # Getter methods for explicit key state variables
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:700
+    // tests/artifacts/StateOps/contract.py:728-729
+    // # Getter methods for explicit key state variables
     // @arc4.abimethod()
-    callsub get_implicit_key_arc4_dynamic_bytes
-    byte 0x151f7c75
+    callsub get_arc4_uint
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_uint_route@10:
-    // tests/artifacts/StateOps/contract.py:704-705
-    // # Getter methods for explicit key state variables
+main_get_implicit_key_arc4_dynamic_bytes_route@12:
+    // tests/artifacts/StateOps/contract.py:724
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:704-705
-    // # Getter methods for explicit key state variables
+    // tests/artifacts/StateOps/contract.py:724
     // @arc4.abimethod()
-    callsub get_arc4_uint
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_dynamic_bytes
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_string_route@11:
-    // tests/artifacts/StateOps/contract.py:709
+main_get_implicit_key_arc4_uint128_route@11:
+    // tests/artifacts/StateOps/contract.py:720
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:709
+    // tests/artifacts/StateOps/contract.py:720
     // @arc4.abimethod()
-    callsub get_arc4_string
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_uint128
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_byte_route@12:
-    // tests/artifacts/StateOps/contract.py:713
+main_get_implicit_key_arc4_address_route@10:
+    // tests/artifacts/StateOps/contract.py:716
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:713
+    // tests/artifacts/StateOps/contract.py:716
     // @arc4.abimethod()
-    callsub get_arc4_byte
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_address
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_bool_route@13:
-    // tests/artifacts/StateOps/contract.py:717
+main_get_implicit_key_arc4_bool_route@9:
+    // tests/artifacts/StateOps/contract.py:712
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:717
+    // tests/artifacts/StateOps/contract.py:712
     // @arc4.abimethod()
-    callsub get_arc4_bool
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_bool
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_address_route@14:
-    // tests/artifacts/StateOps/contract.py:721
+main_get_implicit_key_arc4_byte_route@8:
+    // tests/artifacts/StateOps/contract.py:708
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:721
+    // tests/artifacts/StateOps/contract.py:708
     // @arc4.abimethod()
-    callsub get_arc4_address
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_byte
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_uint128_route@15:
-    // tests/artifacts/StateOps/contract.py:725
+main_get_implicit_key_arc4_string_route@7:
+    // tests/artifacts/StateOps/contract.py:704
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:725
+    // tests/artifacts/StateOps/contract.py:704
     // @arc4.abimethod()
-    callsub get_arc4_uint128
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_string
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_get_arc4_dynamic_bytes_route@16:
-    // tests/artifacts/StateOps/contract.py:729
+main_get_implicit_key_arc4_uint_route@6:
+    // tests/artifacts/StateOps/contract.py:699-700
+    // # Getter methods for implicit key state variables
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:631
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:729
+    // tests/artifacts/StateOps/contract.py:699-700
+    // # Getter methods for implicit key state variables
     // @arc4.abimethod()
-    callsub get_arc4_dynamic_bytes
-    byte 0x151f7c75
+    callsub get_implicit_key_arc4_uint
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
+    return
+
+main_opt_in_route@5:
+    // tests/artifacts/StateOps/contract.py:677
+    // @arc4.abimethod(allow_actions=["OptIn"])
+    txn OnCompletion
+    intc_0 // OptIn
+    ==
+    assert // OnCompletion is not OptIn
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub opt_in
+    intc_0 // 1
     return
 
-main_bare_routing@19:
-    // tests/artifacts/StateOps/contract.py:631
+main_bare_routing@20:
+    // tests/artifacts/StateOps/contract.py:655
     // class LocalStateContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@22
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
 opt_in:
-    // tests/artifacts/StateOps/contract.py:653-654
-    // @arc4.abimethod(allow_actions=["OptIn"])
-    // def opt_in(self) -> None:
-    proto 0 0
-    // tests/artifacts/StateOps/contract.py:655
+    // tests/artifacts/StateOps/contract.py:679
     // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:633-634
-    // # Implicit key state variables
-    // self.implicit_key_arc4_uint = LocalState(arc4.UInt64)
-    byte "implicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:655
-    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
-    byte 0x0000000000000539
+    bytec_1 // "implicit_key_arc4_uint"
+    bytec_2 // 0x0000000000000539
     app_local_put
-    // tests/artifacts/StateOps/contract.py:656
+    // tests/artifacts/StateOps/contract.py:680
     // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:635
-    // self.implicit_key_arc4_string = LocalState(arc4.String)
-    byte "implicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:656
-    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
-    byte 0x000548656c6c6f
+    bytec_3 // "implicit_key_arc4_string"
+    bytec 4 // 0x000548656c6c6f
     app_local_put
-    // tests/artifacts/StateOps/contract.py:657
+    // tests/artifacts/StateOps/contract.py:681
     // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:636
-    // self.implicit_key_arc4_byte = LocalState(arc4.Byte)
-    byte "implicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:657
-    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
-    byte 0x00
+    bytec 5 // "implicit_key_arc4_byte"
+    pushbytes 0x00
     app_local_put
-    // tests/artifacts/StateOps/contract.py:658
+    // tests/artifacts/StateOps/contract.py:682
     // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:637
-    // self.implicit_key_arc4_bool = LocalState(arc4.Bool)
-    byte "implicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:658
-    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
-    byte 0x80
+    bytec 6 // "implicit_key_arc4_bool"
+    pushbytes 0x80
     app_local_put
-    // tests/artifacts/StateOps/contract.py:659
+    // tests/artifacts/StateOps/contract.py:683
     // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:638
-    // self.implicit_key_arc4_address = LocalState(arc4.Address)
-    byte "implicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:660
+    bytec 7 // "implicit_key_arc4_address"
+    // tests/artifacts/StateOps/contract.py:684
     // Global.creator_address
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:659-661
+    // tests/artifacts/StateOps/contract.py:683-685
     // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
     //     Global.creator_address
     // )
     app_local_put
-    // tests/artifacts/StateOps/contract.py:662
+    // tests/artifacts/StateOps/contract.py:686
     // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:639
-    // self.implicit_key_arc4_uint128 = LocalState(arc4.UInt128)
-    byte "implicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:662
-    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
-    byte 0x00000010000000000000000000000000
+    bytec 8 // "implicit_key_arc4_uint128"
+    bytec 9 // 0x00000010000000000000000000000000
     app_local_put
-    // tests/artifacts/StateOps/contract.py:663
+    // tests/artifacts/StateOps/contract.py:687
     // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:640
-    // self.implicit_key_arc4_dynamic_bytes = LocalState(arc4.DynamicBytes)
-    byte "implicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:663-665
+    bytec 10 // "implicit_key_arc4_dynamic_bytes"
+    // tests/artifacts/StateOps/contract.py:687-689
     // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
     //     b"dynamic bytes"
     // )
-    byte 0x000d64796e616d6963206279746573
+    bytec 11 // 0x000d64796e616d6963206279746573
     app_local_put
-    // tests/artifacts/StateOps/contract.py:667
+    // tests/artifacts/StateOps/contract.py:691
     // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:642-643
-    // # Explicit key state variables
-    // self.arc4_uint = LocalState(arc4.UInt64, key="explicit_key_arc4_uint")
-    byte "explicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:667
-    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
-    byte 0x0000000000000539
+    bytec 12 // "explicit_key_arc4_uint"
+    bytec_2 // 0x0000000000000539
     app_local_put
-    // tests/artifacts/StateOps/contract.py:668
+    // tests/artifacts/StateOps/contract.py:692
     // self.arc4_string[Global.creator_address] = arc4.String("Hello")
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:644
-    // self.arc4_string = LocalState(arc4.String, key="explicit_key_arc4_string")
-    byte "explicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:668
-    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
-    byte 0x000548656c6c6f
+    bytec 13 // "explicit_key_arc4_string"
+    bytec 4 // 0x000548656c6c6f
     app_local_put
-    // tests/artifacts/StateOps/contract.py:669
+    // tests/artifacts/StateOps/contract.py:693
     // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:645
-    // self.arc4_byte = LocalState(arc4.Byte, key="explicit_key_arc4_byte")
-    byte "explicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:669
-    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
-    byte 0x00
+    bytec 14 // "explicit_key_arc4_byte"
+    pushbytes 0x00
     app_local_put
-    // tests/artifacts/StateOps/contract.py:670
+    // tests/artifacts/StateOps/contract.py:694
     // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:646
-    // self.arc4_bool = LocalState(arc4.Bool, key="explicit_key_arc4_bool")
-    byte "explicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:670
-    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
-    byte 0x80
+    bytec 15 // "explicit_key_arc4_bool"
+    pushbytes 0x80
     app_local_put
-    // tests/artifacts/StateOps/contract.py:671
+    // tests/artifacts/StateOps/contract.py:695
     // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:647
-    // self.arc4_address = LocalState(arc4.Address, key="explicit_key_arc4_address")
-    byte "explicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:671
-    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
+    bytec 16 // "explicit_key_arc4_address"
     global CreatorAddress
     app_local_put
-    // tests/artifacts/StateOps/contract.py:672
+    // tests/artifacts/StateOps/contract.py:696
     // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:648
-    // self.arc4_uint128 = LocalState(arc4.UInt128, key="explicit_key_arc4_uint128")
-    byte "explicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:672
-    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
-    byte 0x00000010000000000000000000000000
+    bytec 17 // "explicit_key_arc4_uint128"
+    bytec 9 // 0x00000010000000000000000000000000
     app_local_put
-    // tests/artifacts/StateOps/contract.py:673
+    // tests/artifacts/StateOps/contract.py:697
     // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:650
-    // arc4.DynamicBytes, key="explicit_key_arc4_dynamic_bytes"
-    byte "explicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:673
-    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
-    byte 0x000d64796e616d6963206279746573
+    bytec 18 // "explicit_key_arc4_dynamic_bytes"
+    bytec 11 // 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:675-677
+    // tests/artifacts/StateOps/contract.py:699-701
     // # 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:678
+    // tests/artifacts/StateOps/contract.py:702
     // return self.implicit_key_arc4_uint[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:633-634
-    // # Implicit key state variables
-    // self.implicit_key_arc4_uint = LocalState(arc4.UInt64)
-    byte "implicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:678
-    // return self.implicit_key_arc4_uint[a]
+    intc_1 // 0
+    bytec_1 // "implicit_key_arc4_uint"
     app_local_get_ex
     assert // check self.implicit_key_arc4_uint exists for account
     retsub
@@ -557,19 +488,15 @@ get_implicit_key_arc4_uint:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_string(a: bytes) -> bytes:
 get_implicit_key_arc4_string:
-    // tests/artifacts/StateOps/contract.py:680-681
+    // tests/artifacts/StateOps/contract.py:704-705
     // @arc4.abimethod()
     // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:682
+    // tests/artifacts/StateOps/contract.py:706
     // return self.implicit_key_arc4_string[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:635
-    // self.implicit_key_arc4_string = LocalState(arc4.String)
-    byte "implicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:682
-    // return self.implicit_key_arc4_string[a]
+    intc_1 // 0
+    bytec_3 // "implicit_key_arc4_string"
     app_local_get_ex
     assert // check self.implicit_key_arc4_string exists for account
     retsub
@@ -577,19 +504,15 @@ get_implicit_key_arc4_string:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_byte(a: bytes) -> bytes:
 get_implicit_key_arc4_byte:
-    // tests/artifacts/StateOps/contract.py:684-685
+    // tests/artifacts/StateOps/contract.py:708-709
     // @arc4.abimethod()
     // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:686
+    // tests/artifacts/StateOps/contract.py:710
     // return self.implicit_key_arc4_byte[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:636
-    // self.implicit_key_arc4_byte = LocalState(arc4.Byte)
-    byte "implicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:686
-    // return self.implicit_key_arc4_byte[a]
+    intc_1 // 0
+    bytec 5 // "implicit_key_arc4_byte"
     app_local_get_ex
     assert // check self.implicit_key_arc4_byte exists for account
     retsub
@@ -597,19 +520,15 @@ get_implicit_key_arc4_byte:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_bool(a: bytes) -> bytes:
 get_implicit_key_arc4_bool:
-    // tests/artifacts/StateOps/contract.py:688-689
+    // tests/artifacts/StateOps/contract.py:712-713
     // @arc4.abimethod()
     // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:690
+    // tests/artifacts/StateOps/contract.py:714
     // return self.implicit_key_arc4_bool[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:637
-    // self.implicit_key_arc4_bool = LocalState(arc4.Bool)
-    byte "implicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:690
-    // return self.implicit_key_arc4_bool[a]
+    intc_1 // 0
+    bytec 6 // "implicit_key_arc4_bool"
     app_local_get_ex
     assert // check self.implicit_key_arc4_bool exists for account
     retsub
@@ -617,19 +536,15 @@ get_implicit_key_arc4_bool:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_address(a: bytes) -> bytes:
 get_implicit_key_arc4_address:
-    // tests/artifacts/StateOps/contract.py:692-693
+    // tests/artifacts/StateOps/contract.py:716-717
     // @arc4.abimethod()
     // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:694
+    // tests/artifacts/StateOps/contract.py:718
     // return self.implicit_key_arc4_address[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:638
-    // self.implicit_key_arc4_address = LocalState(arc4.Address)
-    byte "implicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:694
-    // return self.implicit_key_arc4_address[a]
+    intc_1 // 0
+    bytec 7 // "implicit_key_arc4_address"
     app_local_get_ex
     assert // check self.implicit_key_arc4_address exists for account
     retsub
@@ -637,19 +552,15 @@ get_implicit_key_arc4_address:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_implicit_key_arc4_uint128(a: bytes) -> bytes:
 get_implicit_key_arc4_uint128:
-    // tests/artifacts/StateOps/contract.py:696-697
+    // tests/artifacts/StateOps/contract.py:720-721
     // @arc4.abimethod()
     // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:698
+    // tests/artifacts/StateOps/contract.py:722
     // return self.implicit_key_arc4_uint128[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:639
-    // self.implicit_key_arc4_uint128 = LocalState(arc4.UInt128)
-    byte "implicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:698
-    // return self.implicit_key_arc4_uint128[a]
+    intc_1 // 0
+    bytec 8 // "implicit_key_arc4_uint128"
     app_local_get_ex
     assert // check self.implicit_key_arc4_uint128 exists for account
     retsub
@@ -657,19 +568,15 @@ get_implicit_key_arc4_uint128:
 
 // 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:700-701
+    // tests/artifacts/StateOps/contract.py:724-725
     // @arc4.abimethod()
     // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:702
+    // tests/artifacts/StateOps/contract.py:726
     // return self.implicit_key_arc4_dynamic_bytes[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:640
-    // self.implicit_key_arc4_dynamic_bytes = LocalState(arc4.DynamicBytes)
-    byte "implicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:702
-    // return self.implicit_key_arc4_dynamic_bytes[a]
+    intc_1 // 0
+    bytec 10 // "implicit_key_arc4_dynamic_bytes"
     app_local_get_ex
     assert // check self.implicit_key_arc4_dynamic_bytes exists for account
     retsub
@@ -677,21 +584,16 @@ get_implicit_key_arc4_dynamic_bytes:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint(a: bytes) -> bytes:
 get_arc4_uint:
-    // tests/artifacts/StateOps/contract.py:704-706
+    // tests/artifacts/StateOps/contract.py:728-730
     // # 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:707
+    // tests/artifacts/StateOps/contract.py:731
     // return self.arc4_uint[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:642-643
-    // # Explicit key state variables
-    // self.arc4_uint = LocalState(arc4.UInt64, key="explicit_key_arc4_uint")
-    byte "explicit_key_arc4_uint"
-    // tests/artifacts/StateOps/contract.py:707
-    // return self.arc4_uint[a]
+    intc_1 // 0
+    bytec 12 // "explicit_key_arc4_uint"
     app_local_get_ex
     assert // check self.arc4_uint exists for account
     retsub
@@ -699,19 +601,15 @@ get_arc4_uint:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_string(a: bytes) -> bytes:
 get_arc4_string:
-    // tests/artifacts/StateOps/contract.py:709-710
+    // tests/artifacts/StateOps/contract.py:733-734
     // @arc4.abimethod()
     // def get_arc4_string(self, a: Account) -> arc4.String:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:711
+    // tests/artifacts/StateOps/contract.py:735
     // return self.arc4_string[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:644
-    // self.arc4_string = LocalState(arc4.String, key="explicit_key_arc4_string")
-    byte "explicit_key_arc4_string"
-    // tests/artifacts/StateOps/contract.py:711
-    // return self.arc4_string[a]
+    intc_1 // 0
+    bytec 13 // "explicit_key_arc4_string"
     app_local_get_ex
     assert // check self.arc4_string exists for account
     retsub
@@ -719,19 +617,15 @@ get_arc4_string:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_byte(a: bytes) -> bytes:
 get_arc4_byte:
-    // tests/artifacts/StateOps/contract.py:713-714
+    // tests/artifacts/StateOps/contract.py:737-738
     // @arc4.abimethod()
     // def get_arc4_byte(self, a: Account) -> arc4.Byte:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:715
+    // tests/artifacts/StateOps/contract.py:739
     // return self.arc4_byte[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:645
-    // self.arc4_byte = LocalState(arc4.Byte, key="explicit_key_arc4_byte")
-    byte "explicit_key_arc4_byte"
-    // tests/artifacts/StateOps/contract.py:715
-    // return self.arc4_byte[a]
+    intc_1 // 0
+    bytec 14 // "explicit_key_arc4_byte"
     app_local_get_ex
     assert // check self.arc4_byte exists for account
     retsub
@@ -739,19 +633,15 @@ get_arc4_byte:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_bool(a: bytes) -> bytes:
 get_arc4_bool:
-    // tests/artifacts/StateOps/contract.py:717-718
+    // tests/artifacts/StateOps/contract.py:741-742
     // @arc4.abimethod()
     // def get_arc4_bool(self, a: Account) -> arc4.Bool:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:719
+    // tests/artifacts/StateOps/contract.py:743
     // return self.arc4_bool[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:646
-    // self.arc4_bool = LocalState(arc4.Bool, key="explicit_key_arc4_bool")
-    byte "explicit_key_arc4_bool"
-    // tests/artifacts/StateOps/contract.py:719
-    // return self.arc4_bool[a]
+    intc_1 // 0
+    bytec 15 // "explicit_key_arc4_bool"
     app_local_get_ex
     assert // check self.arc4_bool exists for account
     retsub
@@ -759,19 +649,15 @@ get_arc4_bool:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_address(a: bytes) -> bytes:
 get_arc4_address:
-    // tests/artifacts/StateOps/contract.py:721-722
+    // tests/artifacts/StateOps/contract.py:745-746
     // @arc4.abimethod()
     // def get_arc4_address(self, a: Account) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:723
+    // tests/artifacts/StateOps/contract.py:747
     // return self.arc4_address[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:647
-    // self.arc4_address = LocalState(arc4.Address, key="explicit_key_arc4_address")
-    byte "explicit_key_arc4_address"
-    // tests/artifacts/StateOps/contract.py:723
-    // return self.arc4_address[a]
+    intc_1 // 0
+    bytec 16 // "explicit_key_arc4_address"
     app_local_get_ex
     assert // check self.arc4_address exists for account
     retsub
@@ -779,19 +665,15 @@ get_arc4_address:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint128(a: bytes) -> bytes:
 get_arc4_uint128:
-    // tests/artifacts/StateOps/contract.py:725-726
+    // tests/artifacts/StateOps/contract.py:749-750
     // @arc4.abimethod()
     // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:727
+    // tests/artifacts/StateOps/contract.py:751
     // return self.arc4_uint128[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:648
-    // self.arc4_uint128 = LocalState(arc4.UInt128, key="explicit_key_arc4_uint128")
-    byte "explicit_key_arc4_uint128"
-    // tests/artifacts/StateOps/contract.py:727
-    // return self.arc4_uint128[a]
+    intc_1 // 0
+    bytec 17 // "explicit_key_arc4_uint128"
     app_local_get_ex
     assert // check self.arc4_uint128 exists for account
     retsub
@@ -799,19 +681,15 @@ get_arc4_uint128:
 
 // tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_dynamic_bytes(a: bytes) -> bytes:
 get_arc4_dynamic_bytes:
-    // tests/artifacts/StateOps/contract.py:729-730
+    // tests/artifacts/StateOps/contract.py:753-754
     // @arc4.abimethod()
     // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:731
+    // tests/artifacts/StateOps/contract.py:755
     // return self.arc4_dynamic_bytes[a]
     frame_dig -1
-    int 0
-    // tests/artifacts/StateOps/contract.py:650
-    // arc4.DynamicBytes, key="explicit_key_arc4_dynamic_bytes"
-    byte "explicit_key_arc4_dynamic_bytes"
-    // tests/artifacts/StateOps/contract.py:731
-    // return self.arc4_dynamic_bytes[a]
+    intc_1 // 0
+    bytec 18 // "explicit_key_arc4_dynamic_bytes"
     app_local_get_ex
     assert // check self.arc4_dynamic_bytes exists for account
     retsub
diff --git a/tests/artifacts/StateOps/data/LocalStateContract.arc32.json b/tests/artifacts/StateOps/data/LocalStateContract.arc32.json
index 87297ab..b4aa43c 100644
--- a/tests/artifacts/StateOps/data/LocalStateContract.arc32.json
+++ b/tests/artifacts/StateOps/data/LocalStateContract.arc32.json
@@ -77,8 +77,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.LocalStateContract.approval_program:
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@19
    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_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@2 main_get_implicit_key_arc4_uint_route@3 main_get_implicit_key_arc4_string_route@4 main_get_implicit_key_arc4_byte_route@5 main_get_implicit_key_arc4_bool_route@6 main_get_implicit_key_arc4_address_route@7 main_get_implicit_key_arc4_uint128_route@8 main_get_implicit_key_arc4_dynamic_bytes_route@9 main_get_arc4_uint_route@10 main_get_arc4_string_route@11 main_get_arc4_byte_route@12 main_get_arc4_bool_route@13 main_get_arc4_address_route@14 main_get_arc4_uint128_route@15 main_get_arc4_dynamic_bytes_route@16
    err // reject transaction

main_opt_in_route@2:
    // tests/artifacts/StateOps/contract.py:653
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    int OptIn
    ==
    assert // OnCompletion is OptIn
    txn ApplicationID
    assert // is not creating
    callsub opt_in
    int 1
    return

main_get_implicit_key_arc4_uint_route@3:
    // tests/artifacts/StateOps/contract.py:675-676
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:675-676
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_string_route@4:
    // tests/artifacts/StateOps/contract.py:680
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:680
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_string
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_byte_route@5:
    // tests/artifacts/StateOps/contract.py:684
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:684
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_byte
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_bool_route@6:
    // tests/artifacts/StateOps/contract.py:688
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:688
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_bool
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_address_route@7:
    // tests/artifacts/StateOps/contract.py:692
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:692
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_address
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_uint128_route@8:
    // tests/artifacts/StateOps/contract.py:696
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:696
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint128
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@9:
    // tests/artifacts/StateOps/contract.py:700
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:700
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_dynamic_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_uint_route@10:
    // tests/artifacts/StateOps/contract.py:704-705
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:704-705
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    callsub get_arc4_uint
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_string_route@11:
    // tests/artifacts/StateOps/contract.py:709
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:709
    // @arc4.abimethod()
    callsub get_arc4_string
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_byte_route@12:
    // tests/artifacts/StateOps/contract.py:713
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:713
    // @arc4.abimethod()
    callsub get_arc4_byte
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_bool_route@13:
    // tests/artifacts/StateOps/contract.py:717
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:717
    // @arc4.abimethod()
    callsub get_arc4_bool
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_address_route@14:
    // tests/artifacts/StateOps/contract.py:721
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:721
    // @arc4.abimethod()
    callsub get_arc4_address
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_uint128_route@15:
    // tests/artifacts/StateOps/contract.py:725
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:725
    // @arc4.abimethod()
    callsub get_arc4_uint128
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_get_arc4_dynamic_bytes_route@16:
    // tests/artifacts/StateOps/contract.py:729
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:729
    // @arc4.abimethod()
    callsub get_arc4_dynamic_bytes
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@19:
    // tests/artifacts/StateOps/contract.py:631
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:653-654
    // @arc4.abimethod(allow_actions=["OptIn"])
    // def opt_in(self) -> None:
    proto 0 0
    // tests/artifacts/StateOps/contract.py:655
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:633-634
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = LocalState(arc4.UInt64)
    byte "implicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:655
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    byte 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:656
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:635
    // self.implicit_key_arc4_string = LocalState(arc4.String)
    byte "implicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:656
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    byte 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:657
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:636
    // self.implicit_key_arc4_byte = LocalState(arc4.Byte)
    byte "implicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:657
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    byte 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:658
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:637
    // self.implicit_key_arc4_bool = LocalState(arc4.Bool)
    byte "implicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:658
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    byte 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:659
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:638
    // self.implicit_key_arc4_address = LocalState(arc4.Address)
    byte "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:660
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:659-661
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:662
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:639
    // self.implicit_key_arc4_uint128 = LocalState(arc4.UInt128)
    byte "implicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:662
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    byte 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:663
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:640
    // self.implicit_key_arc4_dynamic_bytes = LocalState(arc4.DynamicBytes)
    byte "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:663-665
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    byte 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:667
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:642-643
    // # Explicit key state variables
    // self.arc4_uint = LocalState(arc4.UInt64, key="explicit_key_arc4_uint")
    byte "explicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:667
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    byte 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:668
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_string = LocalState(arc4.String, key="explicit_key_arc4_string")
    byte "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:668
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    byte 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:669
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:645
    // self.arc4_byte = LocalState(arc4.Byte, key="explicit_key_arc4_byte")
    byte "explicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:669
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    byte 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:670
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:646
    // self.arc4_bool = LocalState(arc4.Bool, key="explicit_key_arc4_bool")
    byte "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:670
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    byte 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:671
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:647
    // self.arc4_address = LocalState(arc4.Address, key="explicit_key_arc4_address")
    byte "explicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:671
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:672
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_uint128 = LocalState(arc4.UInt128, key="explicit_key_arc4_uint128")
    byte "explicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:672
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    byte 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:673
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:650
    // arc4.DynamicBytes, key="explicit_key_arc4_dynamic_bytes"
    byte "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:673
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    byte 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:675-677
    // # 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:678
    // return self.implicit_key_arc4_uint[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:633-634
    // # Implicit key state variables
    // self.implicit_key_arc4_uint = LocalState(arc4.UInt64)
    byte "implicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:678
    // return self.implicit_key_arc4_uint[a]
    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:680-681
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:682
    // return self.implicit_key_arc4_string[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:635
    // self.implicit_key_arc4_string = LocalState(arc4.String)
    byte "implicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:682
    // return self.implicit_key_arc4_string[a]
    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:684-685
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:686
    // return self.implicit_key_arc4_byte[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:636
    // self.implicit_key_arc4_byte = LocalState(arc4.Byte)
    byte "implicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:686
    // return self.implicit_key_arc4_byte[a]
    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:688-689
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:690
    // return self.implicit_key_arc4_bool[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:637
    // self.implicit_key_arc4_bool = LocalState(arc4.Bool)
    byte "implicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:690
    // return self.implicit_key_arc4_bool[a]
    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:692-693
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:694
    // return self.implicit_key_arc4_address[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:638
    // self.implicit_key_arc4_address = LocalState(arc4.Address)
    byte "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:694
    // return self.implicit_key_arc4_address[a]
    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:696-697
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:698
    // return self.implicit_key_arc4_uint128[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:639
    // self.implicit_key_arc4_uint128 = LocalState(arc4.UInt128)
    byte "implicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:698
    // return self.implicit_key_arc4_uint128[a]
    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:700-701
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:702
    // return self.implicit_key_arc4_dynamic_bytes[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:640
    // self.implicit_key_arc4_dynamic_bytes = LocalState(arc4.DynamicBytes)
    byte "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:702
    // return self.implicit_key_arc4_dynamic_bytes[a]
    app_local_get_ex
    assert // check self.implicit_key_arc4_dynamic_bytes exists for account
    retsub


// tests.artifacts.StateOps.contract.LocalStateContract.get_arc4_uint(a: bytes) -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:704-706
    // # 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:707
    // return self.arc4_uint[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:642-643
    // # Explicit key state variables
    // self.arc4_uint = LocalState(arc4.UInt64, key="explicit_key_arc4_uint")
    byte "explicit_key_arc4_uint"
    // tests/artifacts/StateOps/contract.py:707
    // return self.arc4_uint[a]
    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:709-710
    // @arc4.abimethod()
    // def get_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:711
    // return self.arc4_string[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:644
    // self.arc4_string = LocalState(arc4.String, key="explicit_key_arc4_string")
    byte "explicit_key_arc4_string"
    // tests/artifacts/StateOps/contract.py:711
    // return self.arc4_string[a]
    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:713-714
    // @arc4.abimethod()
    // def get_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:715
    // return self.arc4_byte[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:645
    // self.arc4_byte = LocalState(arc4.Byte, key="explicit_key_arc4_byte")
    byte "explicit_key_arc4_byte"
    // tests/artifacts/StateOps/contract.py:715
    // return self.arc4_byte[a]
    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:717-718
    // @arc4.abimethod()
    // def get_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:719
    // return self.arc4_bool[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:646
    // self.arc4_bool = LocalState(arc4.Bool, key="explicit_key_arc4_bool")
    byte "explicit_key_arc4_bool"
    // tests/artifacts/StateOps/contract.py:719
    // return self.arc4_bool[a]
    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:721-722
    // @arc4.abimethod()
    // def get_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:723
    // return self.arc4_address[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:647
    // self.arc4_address = LocalState(arc4.Address, key="explicit_key_arc4_address")
    byte "explicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:723
    // return self.arc4_address[a]
    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:725-726
    // @arc4.abimethod()
    // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:727
    // return self.arc4_uint128[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:648
    // self.arc4_uint128 = LocalState(arc4.UInt128, key="explicit_key_arc4_uint128")
    byte "explicit_key_arc4_uint128"
    // tests/artifacts/StateOps/contract.py:727
    // return self.arc4_uint128[a]
    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:729-730
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:731
    // return self.arc4_dynamic_bytes[a]
    frame_dig -1
    int 0
    // tests/artifacts/StateOps/contract.py:650
    // arc4.DynamicBytes, key="explicit_key_arc4_dynamic_bytes"
    byte "explicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:731
    // return self.arc4_dynamic_bytes[a]
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuTG9jYWxTdGF0ZUNvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NjMxCiAgICAvLyBjbGFzcyBMb2NhbFN0YXRlQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.LocalStateContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 "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 "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:655
    // class LocalStateContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@20
    pushbytess 0x30c6d58a 0x2284b7af 0x26b45756 0xecf633b0 0x3e531223 0x3ed6799d 0x5296d5ca 0x676a87c2 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_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_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_after_if_else@22:
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    intc_1 // 0
    return

main_get_arc4_dynamic_bytes_route@19:
    // tests/artifacts/StateOps/contract.py:753
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:753
    // @arc4.abimethod()
    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:749
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:749
    // @arc4.abimethod()
    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:745
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:745
    // @arc4.abimethod()
    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:741
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:741
    // @arc4.abimethod()
    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:737
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:737
    // @arc4.abimethod()
    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:733
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:733
    // @arc4.abimethod()
    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:728-729
    // # 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:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:728-729
    // # Getter methods for explicit key state variables
    // @arc4.abimethod()
    callsub get_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_dynamic_bytes_route@12:
    // tests/artifacts/StateOps/contract.py:724
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:724
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_dynamic_bytes
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint128_route@11:
    // tests/artifacts/StateOps/contract.py:720
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:720
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint128
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_address_route@10:
    // tests/artifacts/StateOps/contract.py:716
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:716
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_bool_route@9:
    // tests/artifacts/StateOps/contract.py:712
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:712
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_bool
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_byte_route@8:
    // tests/artifacts/StateOps/contract.py:708
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:708
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_byte
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_string_route@7:
    // tests/artifacts/StateOps/contract.py:704
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:704
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_string
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_get_implicit_key_arc4_uint_route@6:
    // tests/artifacts/StateOps/contract.py:699-700
    // # 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:655
    // class LocalStateContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:699-700
    // # Getter methods for implicit key state variables
    // @arc4.abimethod()
    callsub get_implicit_key_arc4_uint
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:677
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_0 // OptIn
    ==
    assert // OnCompletion is not OptIn
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_0 // 1
    return

main_bare_routing@20:
    // tests/artifacts/StateOps/contract.py:655
    // class LocalStateContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@22
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.LocalStateContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:679
    // self.implicit_key_arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec_1 // "implicit_key_arc4_uint"
    bytec_2 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:680
    // self.implicit_key_arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec_3 // "implicit_key_arc4_string"
    bytec 4 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:681
    // self.implicit_key_arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 5 // "implicit_key_arc4_byte"
    pushbytes 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:682
    // self.implicit_key_arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 6 // "implicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:683
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    global CreatorAddress
    bytec 7 // "implicit_key_arc4_address"
    // tests/artifacts/StateOps/contract.py:684
    // Global.creator_address
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:683-685
    // self.implicit_key_arc4_address[Global.creator_address] = arc4.Address(
    //     Global.creator_address
    // )
    app_local_put
    // tests/artifacts/StateOps/contract.py:686
    // self.implicit_key_arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 8 // "implicit_key_arc4_uint128"
    bytec 9 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:687
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    global CreatorAddress
    bytec 10 // "implicit_key_arc4_dynamic_bytes"
    // tests/artifacts/StateOps/contract.py:687-689
    // self.implicit_key_arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(
    //     b"dynamic bytes"
    // )
    bytec 11 // 0x000d64796e616d6963206279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:691
    // self.arc4_uint[Global.creator_address] = arc4.UInt64(1337)
    global CreatorAddress
    bytec 12 // "explicit_key_arc4_uint"
    bytec_2 // 0x0000000000000539
    app_local_put
    // tests/artifacts/StateOps/contract.py:692
    // self.arc4_string[Global.creator_address] = arc4.String("Hello")
    global CreatorAddress
    bytec 13 // "explicit_key_arc4_string"
    bytec 4 // 0x000548656c6c6f
    app_local_put
    // tests/artifacts/StateOps/contract.py:693
    // self.arc4_byte[Global.creator_address] = arc4.Byte(0)
    global CreatorAddress
    bytec 14 // "explicit_key_arc4_byte"
    pushbytes 0x00
    app_local_put
    // tests/artifacts/StateOps/contract.py:694
    // self.arc4_bool[Global.creator_address] = arc4.Bool(True)
    global CreatorAddress
    bytec 15 // "explicit_key_arc4_bool"
    pushbytes 0x80
    app_local_put
    // tests/artifacts/StateOps/contract.py:695
    // self.arc4_address[Global.creator_address] = arc4.Address(Global.creator_address)
    global CreatorAddress
    bytec 16 // "explicit_key_arc4_address"
    global CreatorAddress
    app_local_put
    // tests/artifacts/StateOps/contract.py:696
    // self.arc4_uint128[Global.creator_address] = arc4.UInt128(2**100)
    global CreatorAddress
    bytec 17 // "explicit_key_arc4_uint128"
    bytec 9 // 0x00000010000000000000000000000000
    app_local_put
    // tests/artifacts/StateOps/contract.py:697
    // self.arc4_dynamic_bytes[Global.creator_address] = arc4.DynamicBytes(b"dynamic bytes")
    global CreatorAddress
    bytec 18 // "explicit_key_arc4_dynamic_bytes"
    bytec 11 // 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:699-701
    // # 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:702
    // return self.implicit_key_arc4_uint[a]
    frame_dig -1
    intc_1 // 0
    bytec_1 // "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:704-705
    // @arc4.abimethod()
    // def get_implicit_key_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:706
    // return self.implicit_key_arc4_string[a]
    frame_dig -1
    intc_1 // 0
    bytec_3 // "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:708-709
    // @arc4.abimethod()
    // def get_implicit_key_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:710
    // return self.implicit_key_arc4_byte[a]
    frame_dig -1
    intc_1 // 0
    bytec 5 // "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:712-713
    // @arc4.abimethod()
    // def get_implicit_key_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:714
    // return self.implicit_key_arc4_bool[a]
    frame_dig -1
    intc_1 // 0
    bytec 6 // "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:716-717
    // @arc4.abimethod()
    // def get_implicit_key_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:718
    // return self.implicit_key_arc4_address[a]
    frame_dig -1
    intc_1 // 0
    bytec 7 // "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:720-721
    // @arc4.abimethod()
    // def get_implicit_key_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:722
    // return self.implicit_key_arc4_uint128[a]
    frame_dig -1
    intc_1 // 0
    bytec 8 // "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:724-725
    // @arc4.abimethod()
    // def get_implicit_key_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:726
    // return self.implicit_key_arc4_dynamic_bytes[a]
    frame_dig -1
    intc_1 // 0
    bytec 10 // "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_arc4_uint(a: bytes) -> bytes:
get_arc4_uint:
    // tests/artifacts/StateOps/contract.py:728-730
    // # 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:731
    // return self.arc4_uint[a]
    frame_dig -1
    intc_1 // 0
    bytec 12 // "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:733-734
    // @arc4.abimethod()
    // def get_arc4_string(self, a: Account) -> arc4.String:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:735
    // return self.arc4_string[a]
    frame_dig -1
    intc_1 // 0
    bytec 13 // "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:737-738
    // @arc4.abimethod()
    // def get_arc4_byte(self, a: Account) -> arc4.Byte:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:739
    // return self.arc4_byte[a]
    frame_dig -1
    intc_1 // 0
    bytec 14 // "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:741-742
    // @arc4.abimethod()
    // def get_arc4_bool(self, a: Account) -> arc4.Bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:743
    // return self.arc4_bool[a]
    frame_dig -1
    intc_1 // 0
    bytec 15 // "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:745-746
    // @arc4.abimethod()
    // def get_arc4_address(self, a: Account) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:747
    // return self.arc4_address[a]
    frame_dig -1
    intc_1 // 0
    bytec 16 // "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:749-750
    // @arc4.abimethod()
    // def get_arc4_uint128(self, a: Account) -> arc4.UInt128:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:751
    // return self.arc4_uint128[a]
    frame_dig -1
    intc_1 // 0
    bytec 17 // "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:753-754
    // @arc4.abimethod()
    // def get_arc4_dynamic_bytes(self, a: Account) -> arc4.DynamicBytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:755
    // return self.arc4_dynamic_bytes[a]
    frame_dig -1
    intc_1 // 0
    bytec 18 // "explicit_key_arc4_dynamic_bytes"
    app_local_get_ex
    assert // check self.arc4_dynamic_bytes exists for account
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/LocalStateContract.clear.teal b/tests/artifacts/StateOps/data/LocalStateContract.clear.teal
index 5ca6943..a433105 100644
--- a/tests/artifacts/StateOps/data/LocalStateContract.clear.teal
+++ b/tests/artifacts/StateOps/data/LocalStateContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.LocalStateContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:631
-    // class LocalStateContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal
index 0b5e66e..b2b5d81 100644
--- a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.approval.teal
@@ -1,203 +1,205 @@
-#pragma version 10
+#pragma version 11
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAcctParamsGetContract.approval_program:
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txn NumAppArgs
-    bz main_bare_routing@16
-    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"
+    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@2 main_verify_acct_min_balance_route@3 main_verify_acct_auth_addr_route@4 main_verify_acct_total_num_uint_route@5 main_verify_acct_total_num_byte_slice_route@6 main_verify_acct_total_extra_app_pages_route@7 main_verify_acct_total_apps_created_route@8 main_verify_acct_total_apps_opted_in_route@9 main_verify_acct_total_assets_created_route@10 main_verify_acct_total_assets_route@11 main_verify_acct_total_boxes_route@12 main_verify_acct_total_box_bytes_route@13
-    err // reject transaction
+    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_verify_acct_balance_route@2:
-    // tests/artifacts/StateOps/contract.py:25
+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 NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:25
+    // tests/artifacts/StateOps/contract.py:153
     // @arc4.abimethod()
-    callsub verify_acct_balance
+    callsub verify_acct_last_proposed
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_min_balance_route@3:
-    // tests/artifacts/StateOps/contract.py:38
+main_verify_acct_last_heartbeat_route@16:
+    // tests/artifacts/StateOps/contract.py:145
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:38
+    // tests/artifacts/StateOps/contract.py:145
     // @arc4.abimethod()
-    callsub verify_acct_min_balance
+    callsub verify_acct_last_heartbeat
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_auth_addr_route@4:
-    // tests/artifacts/StateOps/contract.py:51
+main_verify_acct_incentive_eligible_route@15:
+    // tests/artifacts/StateOps/contract.py:137
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // 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
-    byte 0x151f7c75
+    // 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
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_num_uint_route@5:
-    // tests/artifacts/StateOps/contract.py:59
+main_verify_acct_total_box_bytes_route@14:
+    // tests/artifacts/StateOps/contract.py:129
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:59
+    // tests/artifacts/StateOps/contract.py:129
     // @arc4.abimethod()
-    callsub verify_acct_total_num_uint
+    callsub verify_acct_total_box_bytes
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_num_byte_slice_route@6:
-    // tests/artifacts/StateOps/contract.py:67
+main_verify_acct_total_boxes_route@13:
+    // tests/artifacts/StateOps/contract.py:121
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:67
+    // tests/artifacts/StateOps/contract.py:121
     // @arc4.abimethod()
-    callsub verify_acct_total_num_byte_slice
+    callsub verify_acct_total_boxes
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_extra_app_pages_route@7:
-    // tests/artifacts/StateOps/contract.py:77
+main_verify_acct_total_assets_route@12:
+    // tests/artifacts/StateOps/contract.py:113
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:77
+    // tests/artifacts/StateOps/contract.py:113
     // @arc4.abimethod()
-    callsub verify_acct_total_extra_app_pages
+    callsub verify_acct_total_assets
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_apps_created_route@8:
-    // tests/artifacts/StateOps/contract.py:87
+main_verify_acct_total_assets_created_route@11:
+    // tests/artifacts/StateOps/contract.py:103
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:87
+    // tests/artifacts/StateOps/contract.py:103
     // @arc4.abimethod()
-    callsub verify_acct_total_apps_created
+    callsub verify_acct_total_assets_created
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_apps_opted_in_route@9:
+main_verify_acct_total_apps_opted_in_route@10:
     // tests/artifacts/StateOps/contract.py:95
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
@@ -205,119 +207,189 @@ main_verify_acct_total_apps_opted_in_route@9:
     // @arc4.abimethod()
     callsub verify_acct_total_apps_opted_in
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_assets_created_route@10:
-    // tests/artifacts/StateOps/contract.py:103
+main_verify_acct_total_apps_created_route@9:
+    // tests/artifacts/StateOps/contract.py:87
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:103
+    // tests/artifacts/StateOps/contract.py:87
     // @arc4.abimethod()
-    callsub verify_acct_total_assets_created
+    callsub verify_acct_total_apps_created
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_assets_route@11:
-    // tests/artifacts/StateOps/contract.py:113
+main_verify_acct_total_extra_app_pages_route@8:
+    // tests/artifacts/StateOps/contract.py:77
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:113
+    // tests/artifacts/StateOps/contract.py:77
     // @arc4.abimethod()
-    callsub verify_acct_total_assets
+    callsub verify_acct_total_extra_app_pages
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_boxes_route@12:
-    // tests/artifacts/StateOps/contract.py:121
+main_verify_acct_total_num_byte_slice_route@7:
+    // tests/artifacts/StateOps/contract.py:67
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:121
+    // tests/artifacts/StateOps/contract.py:67
     // @arc4.abimethod()
-    callsub verify_acct_total_boxes
+    callsub verify_acct_total_num_byte_slice
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_acct_total_box_bytes_route@13:
-    // tests/artifacts/StateOps/contract.py:129
+main_verify_acct_total_num_uint_route@6:
+    // tests/artifacts/StateOps/contract.py:59
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
+    // class StateAcctParamsGetContract(ARC4Contract, avm_version=11):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
-    // tests/artifacts/StateOps/contract.py:129
+    // tests/artifacts/StateOps/contract.py:59
     // @arc4.abimethod()
-    callsub verify_acct_total_box_bytes
+    callsub verify_acct_total_num_uint
     itob
-    byte 0x151f7c75
+    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
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@16:
+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):
+    // 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 // reject transaction
+    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 // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
@@ -331,20 +403,21 @@ verify_acct_balance:
     // value, funded = op.AcctParamsGet.acct_balance(a)
     frame_dig -1
     acct_params_get AcctBalance
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctBalance
-    cover 2
     // tests/artifacts/StateOps/contract.py:29
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:31
@@ -362,9 +435,10 @@ verify_acct_balance:
     dig 1
     ==
     assert // expected op.balance to match
-    // tests/artifacts/StateOps/contract.py:34
-    // _get_1st_ref_index()
-    callsub _get_1st_ref_index
+    // 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()
@@ -378,19 +452,6 @@ verify_acct_balance:
     retsub
 
 
-// tests.artifacts.StateOps.contract._get_1st_ref_index() -> uint64:
-_get_1st_ref_index:
-    // tests/artifacts/StateOps/contract.py:19-20
-    // @subroutine
-    // def _get_1st_ref_index() -> UInt64:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:21
-    // return op.btoi(Txn.application_args(1))
-    txna ApplicationArgs 1
-    btoi
-    retsub
-
-
 // tests.artifacts.StateOps.contract.StateAcctParamsGetContract.verify_acct_min_balance(a: bytes) -> uint64:
 verify_acct_min_balance:
     // tests/artifacts/StateOps/contract.py:38-39
@@ -401,20 +462,21 @@ verify_acct_min_balance:
     // value, funded = op.AcctParamsGet.acct_min_balance(a)
     frame_dig -1
     acct_params_get AcctMinBalance
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctMinBalance
-    cover 2
     // tests/artifacts/StateOps/contract.py:42
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:44
@@ -432,9 +494,10 @@ verify_acct_min_balance:
     dig 1
     ==
     assert // expected op.min_balance to match
-    // tests/artifacts/StateOps/contract.py:47
-    // _get_1st_ref_index()
-    callsub _get_1st_ref_index
+    // 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()
@@ -458,20 +521,21 @@ verify_acct_auth_addr:
     // value, funded = op.AcctParamsGet.acct_auth_addr(a)
     frame_dig -1
     acct_params_get AcctAuthAddr
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctAuthAddr
-    cover 2
     // tests/artifacts/StateOps/contract.py:55
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:57
@@ -489,20 +553,21 @@ verify_acct_total_num_uint:
     // value, funded = op.AcctParamsGet.acct_total_num_uint(a)
     frame_dig -1
     acct_params_get AcctTotalNumUint
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctTotalNumUint
-    cover 2
     // tests/artifacts/StateOps/contract.py:63
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:65
@@ -520,24 +585,23 @@ verify_acct_total_num_byte_slice:
     // value, funded = op.AcctParamsGet.acct_total_num_byte_slice(a)
     frame_dig -1
     acct_params_get AcctTotalNumByteSlice
-    swap
-    // tests/artifacts/StateOps/contract.py:71
-    // _get_1st_ref_index()
-    callsub _get_1st_ref_index
+    // 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
-    cover 2
     // tests/artifacts/StateOps/contract.py:73
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:75
@@ -555,24 +619,23 @@ verify_acct_total_extra_app_pages:
     // value, funded = op.AcctParamsGet.acct_total_extra_app_pages(a)
     frame_dig -1
     acct_params_get AcctTotalExtraAppPages
-    swap
-    // tests/artifacts/StateOps/contract.py:81
-    // _get_1st_ref_index()
-    callsub _get_1st_ref_index
+    // 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
-    cover 2
     // tests/artifacts/StateOps/contract.py:83
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:85
@@ -590,20 +653,21 @@ verify_acct_total_apps_created:
     // value, funded = op.AcctParamsGet.acct_total_apps_created(a)
     frame_dig -1
     acct_params_get AcctTotalAppsCreated
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctTotalAppsCreated
-    cover 2
     // tests/artifacts/StateOps/contract.py:91
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:93
@@ -621,20 +685,21 @@ verify_acct_total_apps_opted_in:
     // value, funded = op.AcctParamsGet.acct_total_apps_opted_in(a)
     frame_dig -1
     acct_params_get AcctTotalAppsOptedIn
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctTotalAppsOptedIn
-    cover 2
     // tests/artifacts/StateOps/contract.py:99
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:101
@@ -652,24 +717,23 @@ verify_acct_total_assets_created:
     // value, funded = op.AcctParamsGet.acct_total_assets_created(a)
     frame_dig -1
     acct_params_get AcctTotalAssetsCreated
-    swap
-    // tests/artifacts/StateOps/contract.py:107
-    // _get_1st_ref_index()
-    callsub _get_1st_ref_index
+    // 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
-    cover 2
     // tests/artifacts/StateOps/contract.py:109
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:111
@@ -687,20 +751,21 @@ verify_acct_total_assets:
     // value, funded = op.AcctParamsGet.acct_total_assets(a)
     frame_dig -1
     acct_params_get AcctTotalAssets
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctTotalAssets
-    cover 2
     // tests/artifacts/StateOps/contract.py:117
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:119
@@ -718,20 +783,21 @@ verify_acct_total_boxes:
     // value, funded = op.AcctParamsGet.acct_total_boxes(a)
     frame_dig -1
     acct_params_get AcctTotalBoxes
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctTotalBoxes
-    cover 2
     // tests/artifacts/StateOps/contract.py:125
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     assert // expected funded by index to match
     // tests/artifacts/StateOps/contract.py:127
@@ -749,22 +815,119 @@ verify_acct_total_box_bytes:
     // value, funded = op.AcctParamsGet.acct_total_box_bytes(a)
     frame_dig -1
     acct_params_get AcctTotalBoxBytes
-    swap
+    // 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())
-    callsub _get_1st_ref_index
     acct_params_get AcctTotalBoxBytes
-    cover 2
     // tests/artifacts/StateOps/contract.py:133
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    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"
-    cover 2
     ==
     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
diff --git a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json
index 16b66ef..628dde3 100644
--- a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.arc32.json
@@ -59,11 +59,26 @@
             "call_config": {
                 "no_op": "CALL"
             }
+        },
+        "verify_acct_incentive_eligible(account)bool": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "verify_acct_last_heartbeat(account)uint64": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "verify_acct_last_proposed(account)uint64": {
+            "call_config": {
+                "no_op": "CALL"
+            }
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.StateAcctParamsGetContract.approval_program:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@16
    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"
    txna ApplicationArgs 0
    match main_verify_acct_balance_route@2 main_verify_acct_min_balance_route@3 main_verify_acct_auth_addr_route@4 main_verify_acct_total_num_uint_route@5 main_verify_acct_total_num_byte_slice_route@6 main_verify_acct_total_extra_app_pages_route@7 main_verify_acct_total_apps_created_route@8 main_verify_acct_total_apps_opted_in_route@9 main_verify_acct_total_assets_created_route@10 main_verify_acct_total_assets_route@11 main_verify_acct_total_boxes_route@12 main_verify_acct_total_box_bytes_route@13
    err // reject transaction

main_verify_acct_balance_route@2:
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:25
    // @arc4.abimethod()
    callsub verify_acct_balance
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_min_balance_route@3:
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:38
    // @arc4.abimethod()
    callsub verify_acct_min_balance
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_auth_addr_route@4:
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:51
    // @arc4.abimethod()
    callsub verify_acct_auth_addr
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_num_uint_route@5:
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:59
    // @arc4.abimethod()
    callsub verify_acct_total_num_uint
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_num_byte_slice_route@6:
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:67
    // @arc4.abimethod()
    callsub verify_acct_total_num_byte_slice
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_extra_app_pages_route@7:
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:77
    // @arc4.abimethod()
    callsub verify_acct_total_extra_app_pages
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_apps_created_route@8:
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:87
    // @arc4.abimethod()
    callsub verify_acct_total_apps_created
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_apps_opted_in_route@9:
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:95
    // @arc4.abimethod()
    callsub verify_acct_total_apps_opted_in
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_assets_created_route@10:
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:103
    // @arc4.abimethod()
    callsub verify_acct_total_assets_created
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_assets_route@11:
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:113
    // @arc4.abimethod()
    callsub verify_acct_total_assets
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_boxes_route@12:
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:121
    // @arc4.abimethod()
    callsub verify_acct_total_boxes
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_acct_total_box_bytes_route@13:
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    // tests/artifacts/StateOps/contract.py:129
    // @arc4.abimethod()
    callsub verify_acct_total_box_bytes
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@16:
    // tests/artifacts/StateOps/contract.py:24
    // class StateAcctParamsGetContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 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
    swap
    // tests/artifacts/StateOps/contract.py:28
    // value_index, funded_index = op.AcctParamsGet.acct_balance(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctBalance
    cover 2
    // tests/artifacts/StateOps/contract.py:29
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:30
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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:34
    // _get_1st_ref_index()
    callsub _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
    ==
    assert // expected op.balance by index to match
    // tests/artifacts/StateOps/contract.py:36
    // return value
    retsub


// tests.artifacts.StateOps.contract._get_1st_ref_index() -> uint64:
_get_1st_ref_index:
    // tests/artifacts/StateOps/contract.py:19-20
    // @subroutine
    // def _get_1st_ref_index() -> UInt64:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    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
    swap
    // tests/artifacts/StateOps/contract.py:41
    // value_index, funded_index = op.AcctParamsGet.acct_min_balance(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctMinBalance
    cover 2
    // tests/artifacts/StateOps/contract.py:42
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:43
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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:47
    // _get_1st_ref_index()
    callsub _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
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:54
    // value_index, funded_index = op.AcctParamsGet.acct_auth_addr(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctAuthAddr
    cover 2
    // tests/artifacts/StateOps/contract.py:55
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:56
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:62
    // value_index, funded_index = op.AcctParamsGet.acct_total_num_uint(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctTotalNumUint
    cover 2
    // tests/artifacts/StateOps/contract.py:63
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:64
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:71
    // _get_1st_ref_index()
    callsub _get_1st_ref_index
    // 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
    cover 2
    // tests/artifacts/StateOps/contract.py:73
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:74
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:81
    // _get_1st_ref_index()
    callsub _get_1st_ref_index
    // 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
    cover 2
    // tests/artifacts/StateOps/contract.py:83
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:84
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:90
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_created(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctTotalAppsCreated
    cover 2
    // tests/artifacts/StateOps/contract.py:91
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:92
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:98
    // value_index, funded_index = op.AcctParamsGet.acct_total_apps_opted_in(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctTotalAppsOptedIn
    cover 2
    // tests/artifacts/StateOps/contract.py:99
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:100
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:107
    // _get_1st_ref_index()
    callsub _get_1st_ref_index
    // 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
    cover 2
    // tests/artifacts/StateOps/contract.py:109
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:110
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:116
    // value_index, funded_index = op.AcctParamsGet.acct_total_assets(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctTotalAssets
    cover 2
    // tests/artifacts/StateOps/contract.py:117
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:118
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:124
    // value_index, funded_index = op.AcctParamsGet.acct_total_boxes(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctTotalBoxes
    cover 2
    // tests/artifacts/StateOps/contract.py:125
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:126
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    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
    swap
    // tests/artifacts/StateOps/contract.py:132
    // value_index, funded_index = op.AcctParamsGet.acct_total_box_bytes(_get_1st_ref_index())
    callsub _get_1st_ref_index
    acct_params_get AcctTotalBoxBytes
    cover 2
    // tests/artifacts/StateOps/contract.py:133
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:134
    // assert funded == funded_index, "expected funded by index to match"
    cover 2
    ==
    assert // expected funded by index to match
    // tests/artifacts/StateOps/contract.py:135
    // return value
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBY2N0UGFyYW1zR2V0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weToyNAogICAgLy8gY2xhc3MgU3RhdGVBY2N0UGFyYW1zR2V0Q29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "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": {
         "global": {
@@ -243,6 +258,45 @@
                 "returns": {
                     "type": "uint64"
                 }
+            },
+            {
+                "name": "verify_acct_incentive_eligible",
+                "args": [
+                    {
+                        "type": "account",
+                        "name": "a"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "bool"
+                }
+            },
+            {
+                "name": "verify_acct_last_heartbeat",
+                "args": [
+                    {
+                        "type": "account",
+                        "name": "a"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64"
+                }
+            },
+            {
+                "name": "verify_acct_last_proposed",
+                "args": [
+                    {
+                        "type": "account",
+                        "name": "a"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64"
+                }
             }
         ],
         "networks": {}
diff --git a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.clear.teal b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.clear.teal
index d07d34f..8843a4b 100644
--- a/tests/artifacts/StateOps/data/StateAcctParamsGetContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAcctParamsGetContract.clear.teal
@@ -1,7 +1,7 @@
-#pragma version 10
+#pragma version 11
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAcctParamsGetContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:24
-    // class StateAcctParamsGetContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalContract.approval.teal b/tests/artifacts/StateOps/data/StateAppGlobalContract.approval.teal
index 8dfab14..cacdec4 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAppGlobalContract.approval.teal
@@ -1,253 +1,254 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppGlobalContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:422
+// tests.artifacts.StateOps.contract.StateAppGlobalContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75 0x00
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@11
-    method "verify_get_bytes(byte[])byte[]"
-    method "verify_get_uint64(byte[])uint64"
-    method "verify_get_ex_bytes(application,byte[])(byte[],bool)"
-    method "verify_get_ex_uint64(application,byte[])(uint64,bool)"
-    method "verify_delete(byte[])void"
-    method "verify_put_uint64(byte[],uint64)void"
-    method "verify_put_bytes(byte[],byte[])void"
+    bz main_bare_routing@12
+    pushbytess 0xa997a187 0x4db8aa41 0x6693ab92 0x857fd923 0x93a852e1 0x36996451 0x3920a57b // method "verify_get_bytes(byte[])byte[]", method "verify_get_uint64(byte[])uint64", method "verify_get_ex_bytes(application,byte[])(byte[],bool)", method "verify_get_ex_uint64(application,byte[])(uint64,bool)", method "verify_delete(byte[])void", method "verify_put_uint64(byte[],uint64)void", method "verify_put_bytes(byte[],byte[])void"
     txna ApplicationArgs 0
-    match main_verify_get_bytes_route@2 main_verify_get_uint64_route@3 main_verify_get_ex_bytes_route@4 main_verify_get_ex_uint64_route@5 main_verify_delete_route@6 main_verify_put_uint64_route@7 main_verify_put_bytes_route@8
-    err // reject transaction
+    match main_verify_get_bytes_route@5 main_verify_get_uint64_route@6 main_verify_get_ex_bytes_route@7 main_verify_get_ex_uint64_route@8 main_verify_delete_route@9 main_verify_put_uint64_route@10 main_verify_put_bytes_route@11
 
-main_verify_get_bytes_route@2:
-    // tests/artifacts/StateOps/contract.py:434
+main_after_if_else@14:
+    // tests/artifacts/StateOps/contract.py:446
+    // class StateAppGlobalContract(ARC4Contract):
+    intc_1 // 0
+    return
+
+main_verify_put_bytes_route@11:
+    // tests/artifacts/StateOps/contract.py:484
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:434
+    txna ApplicationArgs 2
+    extract 2 0
+    // tests/artifacts/StateOps/contract.py:484
     // @arc4.abimethod()
-    callsub verify_get_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_put_bytes
+    intc_0 // 1
     return
 
-main_verify_get_uint64_route@3:
-    // tests/artifacts/StateOps/contract.py:439
+main_verify_put_uint64_route@10:
+    // tests/artifacts/StateOps/contract.py:480
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:439
+    txna ApplicationArgs 2
+    btoi
+    // tests/artifacts/StateOps/contract.py:480
     // @arc4.abimethod()
-    callsub verify_get_uint64
-    itob
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_put_uint64
+    intc_0 // 1
     return
 
-main_verify_get_ex_bytes_route@4:
-    // tests/artifacts/StateOps/contract.py:444
+main_verify_delete_route@9:
+    // tests/artifacts/StateOps/contract.py:476
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
-    btoi
-    txnas Applications
-    txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:444
+    // tests/artifacts/StateOps/contract.py:476
     // @arc4.abimethod()
-    callsub verify_get_ex_bytes
-    swap
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x00
-    int 0
-    uncover 3
-    setbit
-    byte 0x0003
-    swap
-    concat
-    swap
-    concat
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_delete
+    intc_0 // 1
     return
 
-main_verify_get_ex_uint64_route@5:
-    // tests/artifacts/StateOps/contract.py:448
+main_verify_get_ex_uint64_route@8:
+    // tests/artifacts/StateOps/contract.py:472
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:448
+    // tests/artifacts/StateOps/contract.py:472
     // @arc4.abimethod()
     callsub verify_get_ex_uint64
     swap
     itob
-    byte 0x00
-    int 0
+    bytec_1 // 0x00
+    intc_1 // 0
     uncover 3
     setbit
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_delete_route@6:
-    // tests/artifacts/StateOps/contract.py:452
+main_verify_get_ex_bytes_route@7:
+    // tests/artifacts/StateOps/contract.py:468
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
+    btoi
+    txnas Applications
+    txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:452
+    // tests/artifacts/StateOps/contract.py:468
     // @arc4.abimethod()
-    callsub verify_delete
-    int 1
+    callsub verify_get_ex_bytes
+    dig 1
+    len
+    itob
+    extract 6 2
+    uncover 2
+    concat
+    bytec_1 // 0x00
+    intc_1 // 0
+    uncover 3
+    setbit
+    pushbytes 0x0003
+    swap
+    concat
+    swap
+    concat
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_verify_put_uint64_route@7:
-    // tests/artifacts/StateOps/contract.py:456
+main_verify_get_uint64_route@6:
+    // tests/artifacts/StateOps/contract.py:463
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
-    txna ApplicationArgs 2
-    btoi
-    // tests/artifacts/StateOps/contract.py:456
+    // tests/artifacts/StateOps/contract.py:463
     // @arc4.abimethod()
-    callsub verify_put_uint64
-    int 1
+    callsub verify_get_uint64
+    itob
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_verify_put_bytes_route@8:
-    // tests/artifacts/StateOps/contract.py:460
+main_verify_get_bytes_route@5:
+    // tests/artifacts/StateOps/contract.py:458
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:422
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txna ApplicationArgs 1
     extract 2 0
-    txna ApplicationArgs 2
-    extract 2 0
-    // tests/artifacts/StateOps/contract.py:460
+    // tests/artifacts/StateOps/contract.py:458
     // @arc4.abimethod()
-    callsub verify_put_bytes
-    int 1
+    callsub verify_get_bytes
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_bare_routing@11:
-    // tests/artifacts/StateOps/contract.py:422
+main_bare_routing@12:
+    // tests/artifacts/StateOps/contract.py:446
     // class StateAppGlobalContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@14
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_bytes(a: bytes) -> bytes:
 verify_get_bytes:
-    // tests/artifacts/StateOps/contract.py:434-435
+    // tests/artifacts/StateOps/contract.py:458-459
     // @arc4.abimethod()
     // def verify_get_bytes(self, a: Bytes) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:436
+    // tests/artifacts/StateOps/contract.py:460
     // value = op.AppGlobal.get_bytes(a)
     frame_dig -1
     app_global_get
-    // tests/artifacts/StateOps/contract.py:437
+    // tests/artifacts/StateOps/contract.py:461
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_uint64(a: bytes) -> uint64:
 verify_get_uint64:
-    // tests/artifacts/StateOps/contract.py:439-440
+    // tests/artifacts/StateOps/contract.py:463-464
     // @arc4.abimethod()
     // def verify_get_uint64(self, a: Bytes) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:441
+    // tests/artifacts/StateOps/contract.py:465
     // value = op.AppGlobal.get_uint64(a)
     frame_dig -1
     app_global_get
-    // tests/artifacts/StateOps/contract.py:442
+    // tests/artifacts/StateOps/contract.py:466
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_ex_bytes(a: uint64, b: bytes) -> bytes, uint64:
 verify_get_ex_bytes:
-    // tests/artifacts/StateOps/contract.py:444-445
+    // tests/artifacts/StateOps/contract.py:468-469
     // @arc4.abimethod()
     // def verify_get_ex_bytes(self, a: Application, b: Bytes) -> tuple[Bytes, bool]:
     proto 2 2
-    // tests/artifacts/StateOps/contract.py:446
+    // tests/artifacts/StateOps/contract.py:470
     // return op.AppGlobal.get_ex_bytes(a, b)
     frame_dig -2
     frame_dig -1
@@ -257,11 +258,11 @@ verify_get_ex_bytes:
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_ex_uint64(a: uint64, b: bytes) -> uint64, uint64:
 verify_get_ex_uint64:
-    // tests/artifacts/StateOps/contract.py:448-449
+    // tests/artifacts/StateOps/contract.py:472-473
     // @arc4.abimethod()
     // def verify_get_ex_uint64(self, a: Application, b: Bytes) -> tuple[UInt64, bool]:
     proto 2 2
-    // tests/artifacts/StateOps/contract.py:450
+    // tests/artifacts/StateOps/contract.py:474
     // return op.AppGlobal.get_ex_uint64(a, b)
     frame_dig -2
     frame_dig -1
@@ -271,11 +272,11 @@ verify_get_ex_uint64:
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_delete(a: bytes) -> void:
 verify_delete:
-    // tests/artifacts/StateOps/contract.py:452-453
+    // tests/artifacts/StateOps/contract.py:476-477
     // @arc4.abimethod()
     // def verify_delete(self, a: Bytes) -> None:
     proto 1 0
-    // tests/artifacts/StateOps/contract.py:454
+    // tests/artifacts/StateOps/contract.py:478
     // op.AppGlobal.delete(a)
     frame_dig -1
     app_global_del
@@ -284,11 +285,11 @@ verify_delete:
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_put_uint64(a: bytes, b: uint64) -> void:
 verify_put_uint64:
-    // tests/artifacts/StateOps/contract.py:456-457
+    // tests/artifacts/StateOps/contract.py:480-481
     // @arc4.abimethod()
     // def verify_put_uint64(self, a: Bytes, b: UInt64) -> None:
     proto 2 0
-    // tests/artifacts/StateOps/contract.py:458
+    // tests/artifacts/StateOps/contract.py:482
     // op.AppGlobal.put(a, b)
     frame_dig -2
     frame_dig -1
@@ -298,11 +299,11 @@ verify_put_uint64:
 
 // tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_put_bytes(a: bytes, b: bytes) -> void:
 verify_put_bytes:
-    // tests/artifacts/StateOps/contract.py:460-461
+    // tests/artifacts/StateOps/contract.py:484-485
     // @arc4.abimethod()
     // def verify_put_bytes(self, a: Bytes, b: Bytes) -> None:
     proto 2 0
-    // tests/artifacts/StateOps/contract.py:462
+    // tests/artifacts/StateOps/contract.py:486
     // op.AppGlobal.put(a, b)
     frame_dig -2
     frame_dig -1
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalContract.arc32.json b/tests/artifacts/StateOps/data/StateAppGlobalContract.arc32.json
index 0f891de..0bb80c2 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAppGlobalContract.arc32.json
@@ -37,8 +37,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.StateAppGlobalContract.approval_program:
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@11
    method "verify_get_bytes(byte[])byte[]"
    method "verify_get_uint64(byte[])uint64"
    method "verify_get_ex_bytes(application,byte[])(byte[],bool)"
    method "verify_get_ex_uint64(application,byte[])(uint64,bool)"
    method "verify_delete(byte[])void"
    method "verify_put_uint64(byte[],uint64)void"
    method "verify_put_bytes(byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_get_bytes_route@2 main_verify_get_uint64_route@3 main_verify_get_ex_bytes_route@4 main_verify_get_ex_uint64_route@5 main_verify_delete_route@6 main_verify_put_uint64_route@7 main_verify_put_bytes_route@8
    err // reject transaction

main_verify_get_bytes_route@2:
    // tests/artifacts/StateOps/contract.py:434
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/StateOps/contract.py:434
    // @arc4.abimethod()
    callsub verify_get_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_get_uint64_route@3:
    // tests/artifacts/StateOps/contract.py:439
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/StateOps/contract.py:439
    // @arc4.abimethod()
    callsub verify_get_uint64
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_get_ex_bytes_route@4:
    // tests/artifacts/StateOps/contract.py:444
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:444
    // @arc4.abimethod()
    callsub verify_get_ex_bytes
    swap
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x00
    int 0
    uncover 3
    setbit
    byte 0x0003
    swap
    concat
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_get_ex_uint64_route@5:
    // tests/artifacts/StateOps/contract.py:448
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:448
    // @arc4.abimethod()
    callsub verify_get_ex_uint64
    swap
    itob
    byte 0x00
    int 0
    uncover 3
    setbit
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_delete_route@6:
    // tests/artifacts/StateOps/contract.py:452
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/StateOps/contract.py:452
    // @arc4.abimethod()
    callsub verify_delete
    int 1
    return

main_verify_put_uint64_route@7:
    // tests/artifacts/StateOps/contract.py:456
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/StateOps/contract.py:456
    // @arc4.abimethod()
    callsub verify_put_uint64
    int 1
    return

main_verify_put_bytes_route@8:
    // tests/artifacts/StateOps/contract.py:460
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:460
    // @arc4.abimethod()
    callsub verify_put_bytes
    int 1
    return

main_bare_routing@11:
    // tests/artifacts/StateOps/contract.py:422
    // class StateAppGlobalContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_bytes(a: bytes) -> bytes:
verify_get_bytes:
    // tests/artifacts/StateOps/contract.py:434-435
    // @arc4.abimethod()
    // def verify_get_bytes(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:436
    // value = op.AppGlobal.get_bytes(a)
    frame_dig -1
    app_global_get
    // tests/artifacts/StateOps/contract.py:437
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_uint64(a: bytes) -> uint64:
verify_get_uint64:
    // tests/artifacts/StateOps/contract.py:439-440
    // @arc4.abimethod()
    // def verify_get_uint64(self, a: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:441
    // value = op.AppGlobal.get_uint64(a)
    frame_dig -1
    app_global_get
    // tests/artifacts/StateOps/contract.py:442
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_ex_bytes(a: uint64, b: bytes) -> bytes, uint64:
verify_get_ex_bytes:
    // tests/artifacts/StateOps/contract.py:444-445
    // @arc4.abimethod()
    // def verify_get_ex_bytes(self, a: Application, b: Bytes) -> tuple[Bytes, bool]:
    proto 2 2
    // tests/artifacts/StateOps/contract.py:446
    // return op.AppGlobal.get_ex_bytes(a, b)
    frame_dig -2
    frame_dig -1
    app_global_get_ex
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_ex_uint64(a: uint64, b: bytes) -> uint64, uint64:
verify_get_ex_uint64:
    // tests/artifacts/StateOps/contract.py:448-449
    // @arc4.abimethod()
    // def verify_get_ex_uint64(self, a: Application, b: Bytes) -> tuple[UInt64, bool]:
    proto 2 2
    // tests/artifacts/StateOps/contract.py:450
    // return op.AppGlobal.get_ex_uint64(a, b)
    frame_dig -2
    frame_dig -1
    app_global_get_ex
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_delete(a: bytes) -> void:
verify_delete:
    // tests/artifacts/StateOps/contract.py:452-453
    // @arc4.abimethod()
    // def verify_delete(self, a: Bytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:454
    // op.AppGlobal.delete(a)
    frame_dig -1
    app_global_del
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_put_uint64(a: bytes, b: uint64) -> void:
verify_put_uint64:
    // tests/artifacts/StateOps/contract.py:456-457
    // @arc4.abimethod()
    // def verify_put_uint64(self, a: Bytes, b: UInt64) -> None:
    proto 2 0
    // tests/artifacts/StateOps/contract.py:458
    // op.AppGlobal.put(a, b)
    frame_dig -2
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_put_bytes(a: bytes, b: bytes) -> void:
verify_put_bytes:
    // tests/artifacts/StateOps/contract.py:460-461
    // @arc4.abimethod()
    // def verify_put_bytes(self, a: Bytes, b: Bytes) -> None:
    proto 2 0
    // tests/artifacts/StateOps/contract.py:462
    // op.AppGlobal.put(a, b)
    frame_dig -2
    frame_dig -1
    app_global_put
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxDb250cmFjdC5jbGVhcl9zdGF0ZV9wcm9ncmFtOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjQyMgogICAgLy8gY2xhc3MgU3RhdGVBcHBHbG9iYWxDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.StateAppGlobalContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75 0x00
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@12
    pushbytess 0xa997a187 0x4db8aa41 0x6693ab92 0x857fd923 0x93a852e1 0x36996451 0x3920a57b // method "verify_get_bytes(byte[])byte[]", method "verify_get_uint64(byte[])uint64", method "verify_get_ex_bytes(application,byte[])(byte[],bool)", method "verify_get_ex_uint64(application,byte[])(uint64,bool)", method "verify_delete(byte[])void", method "verify_put_uint64(byte[],uint64)void", method "verify_put_bytes(byte[],byte[])void"
    txna ApplicationArgs 0
    match main_verify_get_bytes_route@5 main_verify_get_uint64_route@6 main_verify_get_ex_bytes_route@7 main_verify_get_ex_uint64_route@8 main_verify_delete_route@9 main_verify_put_uint64_route@10 main_verify_put_bytes_route@11

main_after_if_else@14:
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    intc_1 // 0
    return

main_verify_put_bytes_route@11:
    // tests/artifacts/StateOps/contract.py:484
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:484
    // @arc4.abimethod()
    callsub verify_put_bytes
    intc_0 // 1
    return

main_verify_put_uint64_route@10:
    // tests/artifacts/StateOps/contract.py:480
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/StateOps/contract.py:480
    // @arc4.abimethod()
    callsub verify_put_uint64
    intc_0 // 1
    return

main_verify_delete_route@9:
    // tests/artifacts/StateOps/contract.py:476
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/StateOps/contract.py:476
    // @arc4.abimethod()
    callsub verify_delete
    intc_0 // 1
    return

main_verify_get_ex_uint64_route@8:
    // tests/artifacts/StateOps/contract.py:472
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:472
    // @arc4.abimethod()
    callsub verify_get_ex_uint64
    swap
    itob
    bytec_1 // 0x00
    intc_1 // 0
    uncover 3
    setbit
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_get_ex_bytes_route@7:
    // tests/artifacts/StateOps/contract.py:468
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:468
    // @arc4.abimethod()
    callsub verify_get_ex_bytes
    dig 1
    len
    itob
    extract 6 2
    uncover 2
    concat
    bytec_1 // 0x00
    intc_1 // 0
    uncover 3
    setbit
    pushbytes 0x0003
    swap
    concat
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_get_uint64_route@6:
    // tests/artifacts/StateOps/contract.py:463
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/StateOps/contract.py:463
    // @arc4.abimethod()
    callsub verify_get_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_get_bytes_route@5:
    // tests/artifacts/StateOps/contract.py:458
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/StateOps/contract.py:458
    // @arc4.abimethod()
    callsub verify_get_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@12:
    // tests/artifacts/StateOps/contract.py:446
    // class StateAppGlobalContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@14
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_bytes(a: bytes) -> bytes:
verify_get_bytes:
    // tests/artifacts/StateOps/contract.py:458-459
    // @arc4.abimethod()
    // def verify_get_bytes(self, a: Bytes) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:460
    // value = op.AppGlobal.get_bytes(a)
    frame_dig -1
    app_global_get
    // tests/artifacts/StateOps/contract.py:461
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_uint64(a: bytes) -> uint64:
verify_get_uint64:
    // tests/artifacts/StateOps/contract.py:463-464
    // @arc4.abimethod()
    // def verify_get_uint64(self, a: Bytes) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:465
    // value = op.AppGlobal.get_uint64(a)
    frame_dig -1
    app_global_get
    // tests/artifacts/StateOps/contract.py:466
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_ex_bytes(a: uint64, b: bytes) -> bytes, uint64:
verify_get_ex_bytes:
    // tests/artifacts/StateOps/contract.py:468-469
    // @arc4.abimethod()
    // def verify_get_ex_bytes(self, a: Application, b: Bytes) -> tuple[Bytes, bool]:
    proto 2 2
    // tests/artifacts/StateOps/contract.py:470
    // return op.AppGlobal.get_ex_bytes(a, b)
    frame_dig -2
    frame_dig -1
    app_global_get_ex
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_get_ex_uint64(a: uint64, b: bytes) -> uint64, uint64:
verify_get_ex_uint64:
    // tests/artifacts/StateOps/contract.py:472-473
    // @arc4.abimethod()
    // def verify_get_ex_uint64(self, a: Application, b: Bytes) -> tuple[UInt64, bool]:
    proto 2 2
    // tests/artifacts/StateOps/contract.py:474
    // return op.AppGlobal.get_ex_uint64(a, b)
    frame_dig -2
    frame_dig -1
    app_global_get_ex
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_delete(a: bytes) -> void:
verify_delete:
    // tests/artifacts/StateOps/contract.py:476-477
    // @arc4.abimethod()
    // def verify_delete(self, a: Bytes) -> None:
    proto 1 0
    // tests/artifacts/StateOps/contract.py:478
    // op.AppGlobal.delete(a)
    frame_dig -1
    app_global_del
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_put_uint64(a: bytes, b: uint64) -> void:
verify_put_uint64:
    // tests/artifacts/StateOps/contract.py:480-481
    // @arc4.abimethod()
    // def verify_put_uint64(self, a: Bytes, b: UInt64) -> None:
    proto 2 0
    // tests/artifacts/StateOps/contract.py:482
    // op.AppGlobal.put(a, b)
    frame_dig -2
    frame_dig -1
    app_global_put
    retsub


// tests.artifacts.StateOps.contract.StateAppGlobalContract.verify_put_bytes(a: bytes, b: bytes) -> void:
verify_put_bytes:
    // tests/artifacts/StateOps/contract.py:484-485
    // @arc4.abimethod()
    // def verify_put_bytes(self, a: Bytes, b: Bytes) -> None:
    proto 2 0
    // tests/artifacts/StateOps/contract.py:486
    // op.AppGlobal.put(a, b)
    frame_dig -2
    frame_dig -1
    app_global_put
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalContract.clear.teal b/tests/artifacts/StateOps/data/StateAppGlobalContract.clear.teal
index d7a1245..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAppGlobalContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppGlobalContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:422
-    // class StateAppGlobalContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal b/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal
index 35af159..8d13d84 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAppGlobalExContract.approval.teal
@@ -1,77 +1,75 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppGlobalExContract.approval_program:
+// tests.artifacts.StateOps.contract.StateAppGlobalExContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    bytecblock 0x64756d6d795f6279746573 0x001064756d6d795f617263345f6279746573
     txn ApplicationID
-    bnz main_entrypoint@2
-    callsub __init__
-
-main_entrypoint@2:
-    // tests/artifacts/StateOps/contract.py:404
-    // class StateAppGlobalExContract(ARC4Contract):
-    txn NumAppArgs
-    !
-    assert // reject transaction
-    txn OnCompletion
-    !
-    assert // reject transaction
-    txn ApplicationID
-    !
-    assert // is creating
-    int 1
-    return
-
-
-// tests.artifacts.StateOps.contract.StateAppGlobalExContract.__init__() -> void:
-__init__:
-    // tests/artifacts/StateOps/contract.py:405
-    // def __init__(self) -> None:
-    proto 0 0
-    // tests/artifacts/StateOps/contract.py:408
+    bnz main_after_if_else@2
+    // tests/artifacts/StateOps/contract.py:432
     // key="global_uint64",
-    byte "global_uint64"
-    // tests/artifacts/StateOps/contract.py:407
+    pushbytes "global_uint64"
+    // tests/artifacts/StateOps/contract.py:431
     // UInt64(2),
-    int 2
-    // tests/artifacts/StateOps/contract.py:406-409
+    pushint 2 // 2
+    // tests/artifacts/StateOps/contract.py:430-433
     // self.global_uint64 = GlobalState(
     //     UInt64(2),
     //     key="global_uint64",
     // )
     app_global_put
-    // tests/artifacts/StateOps/contract.py:412
+    // tests/artifacts/StateOps/contract.py:436
     // key="global_bytes",
-    byte "global_bytes"
-    // tests/artifacts/StateOps/contract.py:411
+    pushbytes "global_bytes"
+    // tests/artifacts/StateOps/contract.py:435
     // Bytes(b"dummy_bytes"),
-    byte 0x64756d6d795f6279746573
-    // tests/artifacts/StateOps/contract.py:410-413
+    bytec_0 // 0x64756d6d795f6279746573
+    // tests/artifacts/StateOps/contract.py:434-437
     // self.global_bytes = GlobalState(
     //     Bytes(b"dummy_bytes"),
     //     key="global_bytes",
     // )
     app_global_put
-    // tests/artifacts/StateOps/contract.py:414
+    // tests/artifacts/StateOps/contract.py:438
     // self.global_uint64_explicit = algopy.UInt64(2)
-    byte "global_uint64_explicit"
-    int 2
+    pushbytes "global_uint64_explicit"
+    pushint 2 // 2
     app_global_put
-    // tests/artifacts/StateOps/contract.py:415
+    // tests/artifacts/StateOps/contract.py:439
     // self.global_bytes_explicit = algopy.Bytes(b"dummy_bytes")
-    byte "global_bytes_explicit"
-    byte 0x64756d6d795f6279746573
+    pushbytes "global_bytes_explicit"
+    bytec_0 // 0x64756d6d795f6279746573
     app_global_put
-    // tests/artifacts/StateOps/contract.py:417
+    // tests/artifacts/StateOps/contract.py:441
     // algopy.arc4.DynamicBytes(b"dummy_arc4_bytes"), key="global_arc4_bytes"
-    byte "global_arc4_bytes"
-    byte 0x001064756d6d795f617263345f6279746573
-    // tests/artifacts/StateOps/contract.py:416-418
+    pushbytes "global_arc4_bytes"
+    bytec_1 // 0x001064756d6d795f617263345f6279746573
+    // tests/artifacts/StateOps/contract.py:440-442
     // self.global_arc4_bytes = GlobalState(
     //     algopy.arc4.DynamicBytes(b"dummy_arc4_bytes"), key="global_arc4_bytes"
     // )
     app_global_put
-    // tests/artifacts/StateOps/contract.py:419
+    // tests/artifacts/StateOps/contract.py:443
     // self.global_arc4_bytes_explicit = algopy.arc4.DynamicBytes(b"dummy_arc4_bytes")
-    byte "global_arc4_bytes_explicit"
-    byte 0x001064756d6d795f617263345f6279746573
+    pushbytes "global_arc4_bytes_explicit"
+    bytec_1 // 0x001064756d6d795f617263345f6279746573
     app_global_put
-    retsub
+
+main_after_if_else@2:
+    // tests/artifacts/StateOps/contract.py:428
+    // class StateAppGlobalExContract(ARC4Contract):
+    txn NumAppArgs
+    bnz main_after_if_else@6
+    txn OnCompletion
+    bnz main_after_if_else@6
+    txn ApplicationID
+    !
+    assert // can only call when creating
+    pushint 1 // 1
+    return
+
+main_after_if_else@6:
+    // tests/artifacts/StateOps/contract.py:428
+    // class StateAppGlobalExContract(ARC4Contract):
+    pushint 0 // 0
+    return
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json b/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json
index 4492dbf..c2a288d 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAppGlobalExContract.arc32.json
@@ -1,8 +1,8 @@
 {
     "hints": {},
     "source": {
-        "approval": "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",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBHbG9iYWxFeENvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6NDA0CiAgICAvLyBjbGFzcyBTdGF0ZUFwcEdsb2JhbEV4Q29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAppGlobalExContract.clear.teal b/tests/artifacts/StateOps/data/StateAppGlobalExContract.clear.teal
index 3d0e5c8..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAppGlobalExContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAppGlobalExContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppGlobalExContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:404
-    // class StateAppGlobalExContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAppLocalContract.approval.teal b/tests/artifacts/StateOps/data/StateAppLocalContract.approval.teal
index d373649..2829f97 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAppLocalContract.approval.teal
@@ -1,369 +1,356 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppLocalContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:349
+// tests.artifacts.StateOps.contract.StateAppLocalContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@13
-    method "opt_in()void"
-    method "verify_get_bytes(account,byte[])byte[]"
-    method "verify_get_uint64(account,byte[])uint64"
-    method "verify_get_ex_bytes(account,application,byte[])byte[]"
-    method "verify_get_ex_uint64(account,application,byte[])uint64"
-    method "verify_delete(account,byte[])void"
-    method "verify_exists(account,byte[])bool"
-    method "verify_put_uint64(account,byte[],uint64)void"
-    method "verify_put_bytes(account,byte[],byte[])void"
+    bz main_bare_routing@14
+    pushbytess 0x30c6d58a 0x937b5e13 0x8d742b86 0x7a6d0b59 0x594ff1d9 0x95a31727 0xaa1f4792 0x46245287 0x7f0fdfdd // method "opt_in()void", method "verify_get_bytes(account,byte[])byte[]", method "verify_get_uint64(account,byte[])uint64", method "verify_get_ex_bytes(account,application,byte[])byte[]", method "verify_get_ex_uint64(account,application,byte[])uint64", method "verify_delete(account,byte[])void", method "verify_exists(account,byte[])bool", method "verify_put_uint64(account,byte[],uint64)void", method "verify_put_bytes(account,byte[],byte[])void"
     txna ApplicationArgs 0
-    match main_opt_in_route@2 main_verify_get_bytes_route@3 main_verify_get_uint64_route@4 main_verify_get_ex_bytes_route@5 main_verify_get_ex_uint64_route@6 main_verify_delete_route@7 main_verify_exists_route@8 main_verify_put_uint64_route@9 main_verify_put_bytes_route@10
-    err // reject transaction
+    match main_opt_in_route@5 main_verify_get_bytes_route@6 main_verify_get_uint64_route@7 main_verify_get_ex_bytes_route@8 main_verify_get_ex_uint64_route@9 main_verify_delete_route@10 main_verify_exists_route@11 main_verify_put_uint64_route@12 main_verify_put_bytes_route@13
 
-main_opt_in_route@2:
-    // tests/artifacts/StateOps/contract.py:361
-    // @arc4.abimethod(allow_actions=["OptIn"])
-    txn OnCompletion
-    int OptIn
-    ==
-    assert // OnCompletion is OptIn
-    txn ApplicationID
-    assert // is not creating
-    callsub opt_in
-    int 1
+main_after_if_else@16:
+    // tests/artifacts/StateOps/contract.py:373
+    // class StateAppLocalContract(ARC4Contract):
+    intc_1 // 0
     return
 
-main_verify_get_bytes_route@3:
-    // tests/artifacts/StateOps/contract.py:366
+main_verify_put_bytes_route@13:
+    // tests/artifacts/StateOps/contract.py:423
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:366
+    txna ApplicationArgs 3
+    extract 2 0
+    // tests/artifacts/StateOps/contract.py:423
     // @arc4.abimethod()
-    callsub verify_get_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_put_bytes
+    intc_0 // 1
     return
 
-main_verify_get_uint64_route@4:
-    // tests/artifacts/StateOps/contract.py:371
+main_verify_put_uint64_route@12:
+    // tests/artifacts/StateOps/contract.py:419
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:371
+    txna ApplicationArgs 3
+    btoi
+    // tests/artifacts/StateOps/contract.py:419
     // @arc4.abimethod()
-    callsub verify_get_uint64
-    itob
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_put_uint64
+    intc_0 // 1
     return
 
-main_verify_get_ex_bytes_route@5:
-    // tests/artifacts/StateOps/contract.py:376
+main_verify_exists_route@11:
+    // tests/artifacts/StateOps/contract.py:414
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
-    btoi
-    txnas Applications
-    txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:376
+    // tests/artifacts/StateOps/contract.py:414
     // @arc4.abimethod()
-    callsub verify_get_ex_bytes
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_exists
+    pushbytes 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_get_ex_uint64_route@6:
-    // tests/artifacts/StateOps/contract.py:381
+main_verify_delete_route@10:
+    // tests/artifacts/StateOps/contract.py:410
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
-    btoi
-    txnas Applications
-    txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:381
+    // tests/artifacts/StateOps/contract.py:410
     // @arc4.abimethod()
-    callsub verify_get_ex_uint64
-    itob
-    byte 0x151f7c75
-    swap
-    concat
-    log
-    int 1
+    callsub verify_delete
+    intc_0 // 1
     return
 
-main_verify_delete_route@7:
-    // tests/artifacts/StateOps/contract.py:386
+main_verify_get_ex_uint64_route@9:
+    // tests/artifacts/StateOps/contract.py:405
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
+    btoi
+    txnas Applications
+    txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:386
+    // tests/artifacts/StateOps/contract.py:405
     // @arc4.abimethod()
-    callsub verify_delete
-    int 1
+    callsub verify_get_ex_uint64
+    itob
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_verify_exists_route@8:
-    // tests/artifacts/StateOps/contract.py:390
+main_verify_get_ex_bytes_route@8:
+    // tests/artifacts/StateOps/contract.py:400
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
+    btoi
+    txnas Applications
+    txna ApplicationArgs 3
     extract 2 0
-    // tests/artifacts/StateOps/contract.py:390
+    // tests/artifacts/StateOps/contract.py:400
     // @arc4.abimethod()
-    callsub verify_exists
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_get_ex_bytes
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_put_uint64_route@9:
+main_verify_get_uint64_route@7:
     // tests/artifacts/StateOps/contract.py:395
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
     extract 2 0
-    txna ApplicationArgs 3
-    btoi
     // tests/artifacts/StateOps/contract.py:395
     // @arc4.abimethod()
-    callsub verify_put_uint64
-    int 1
+    callsub verify_get_uint64
+    itob
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
     return
 
-main_verify_put_bytes_route@10:
-    // tests/artifacts/StateOps/contract.py:399
+main_verify_get_bytes_route@6:
+    // tests/artifacts/StateOps/contract.py:390
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:349
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Accounts
     txna ApplicationArgs 2
     extract 2 0
-    txna ApplicationArgs 3
-    extract 2 0
-    // tests/artifacts/StateOps/contract.py:399
+    // tests/artifacts/StateOps/contract.py:390
     // @arc4.abimethod()
-    callsub verify_put_bytes
-    int 1
+    callsub verify_get_bytes
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
+    swap
+    concat
+    log
+    intc_0 // 1
+    return
+
+main_opt_in_route@5:
+    // tests/artifacts/StateOps/contract.py:385
+    // @arc4.abimethod(allow_actions=["OptIn"])
+    txn OnCompletion
+    intc_0 // OptIn
+    ==
+    assert // OnCompletion is not OptIn
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub opt_in
+    intc_0 // 1
     return
 
-main_bare_routing@13:
-    // tests/artifacts/StateOps/contract.py:349
+main_bare_routing@14:
+    // tests/artifacts/StateOps/contract.py:373
     // class StateAppLocalContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@16
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.opt_in() -> void:
 opt_in:
-    // tests/artifacts/StateOps/contract.py:361-362
-    // @arc4.abimethod(allow_actions=["OptIn"])
-    // def opt_in(self) -> None:
-    proto 0 0
-    // tests/artifacts/StateOps/contract.py:363
+    // tests/artifacts/StateOps/contract.py:387
     // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes")
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:358
-    // key="local_bytes",
-    byte "local_bytes"
-    // tests/artifacts/StateOps/contract.py:363
-    // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes")
-    byte 0x64756d6d795f6279746573
+    pushbytess "local_bytes" 0x64756d6d795f6279746573 // "local_bytes", 0x64756d6d795f6279746573
     app_local_put
-    // tests/artifacts/StateOps/contract.py:364
+    // tests/artifacts/StateOps/contract.py:388
     // self.local_uint64[Global.creator_address] = UInt64(999)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:353
-    // key="local_uint64",
-    byte "local_uint64"
-    // tests/artifacts/StateOps/contract.py:364
-    // self.local_uint64[Global.creator_address] = UInt64(999)
-    int 999
+    pushbytes "local_uint64"
+    pushint 999 // 999
     app_local_put
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_bytes(a: bytes, b: bytes) -> bytes:
 verify_get_bytes:
-    // tests/artifacts/StateOps/contract.py:366-367
+    // tests/artifacts/StateOps/contract.py:390-391
     // @arc4.abimethod()
     // def verify_get_bytes(self, a: Account, b: Bytes) -> Bytes:
     proto 2 1
-    // tests/artifacts/StateOps/contract.py:368
+    // tests/artifacts/StateOps/contract.py:392
     // value = op.AppLocal.get_bytes(a, b)
     frame_dig -2
     frame_dig -1
     app_local_get
-    // tests/artifacts/StateOps/contract.py:369
+    // tests/artifacts/StateOps/contract.py:393
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_uint64(a: bytes, b: bytes) -> uint64:
 verify_get_uint64:
-    // tests/artifacts/StateOps/contract.py:371-372
+    // tests/artifacts/StateOps/contract.py:395-396
     // @arc4.abimethod()
     // def verify_get_uint64(self, a: Account, b: Bytes) -> UInt64:
     proto 2 1
-    // tests/artifacts/StateOps/contract.py:373
+    // tests/artifacts/StateOps/contract.py:397
     // value = op.AppLocal.get_uint64(a, b)
     frame_dig -2
     frame_dig -1
     app_local_get
-    // tests/artifacts/StateOps/contract.py:374
+    // tests/artifacts/StateOps/contract.py:398
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_bytes(a: bytes, b: uint64, c: bytes) -> bytes:
 verify_get_ex_bytes:
-    // tests/artifacts/StateOps/contract.py:376-377
+    // tests/artifacts/StateOps/contract.py:400-401
     // @arc4.abimethod()
     // def verify_get_ex_bytes(self, a: Account, b: Application, c: Bytes) -> Bytes:
     proto 3 1
-    // tests/artifacts/StateOps/contract.py:378
+    // tests/artifacts/StateOps/contract.py:402
     // value, _val = op.AppLocal.get_ex_bytes(a, b, c)
     frame_dig -3
     frame_dig -2
     frame_dig -1
     app_local_get_ex
     pop
-    // tests/artifacts/StateOps/contract.py:379
+    // tests/artifacts/StateOps/contract.py:403
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_uint64(a: bytes, b: uint64, c: bytes) -> uint64:
 verify_get_ex_uint64:
-    // tests/artifacts/StateOps/contract.py:381-382
+    // tests/artifacts/StateOps/contract.py:405-406
     // @arc4.abimethod()
     // def verify_get_ex_uint64(self, a: Account, b: Application, c: Bytes) -> UInt64:
     proto 3 1
-    // tests/artifacts/StateOps/contract.py:383
+    // tests/artifacts/StateOps/contract.py:407
     // value, _val = op.AppLocal.get_ex_uint64(a, b, c)
     frame_dig -3
     frame_dig -2
     frame_dig -1
     app_local_get_ex
     pop
-    // tests/artifacts/StateOps/contract.py:384
+    // tests/artifacts/StateOps/contract.py:408
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_delete(a: bytes, b: bytes) -> void:
 verify_delete:
-    // tests/artifacts/StateOps/contract.py:386-387
+    // tests/artifacts/StateOps/contract.py:410-411
     // @arc4.abimethod()
     // def verify_delete(self, a: Account, b: Bytes) -> None:
     proto 2 0
-    // tests/artifacts/StateOps/contract.py:388
+    // tests/artifacts/StateOps/contract.py:412
     // op.AppLocal.delete(a, b)
     frame_dig -2
     frame_dig -1
@@ -373,29 +360,29 @@ verify_delete:
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_exists(a: bytes, b: bytes) -> uint64:
 verify_exists:
-    // tests/artifacts/StateOps/contract.py:390-391
+    // tests/artifacts/StateOps/contract.py:414-415
     // @arc4.abimethod()
     // def verify_exists(self, a: Account, b: Bytes) -> bool:
     proto 2 1
-    // tests/artifacts/StateOps/contract.py:392
+    // tests/artifacts/StateOps/contract.py:416
     // _value, exists = op.AppLocal.get_ex_uint64(a, 0, b)
     frame_dig -2
-    int 0
+    intc_1 // 0
     frame_dig -1
     app_local_get_ex
     bury 1
-    // tests/artifacts/StateOps/contract.py:393
+    // tests/artifacts/StateOps/contract.py:417
     // return exists
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_uint64(a: bytes, b: bytes, c: uint64) -> void:
 verify_put_uint64:
-    // tests/artifacts/StateOps/contract.py:395-396
+    // tests/artifacts/StateOps/contract.py:419-420
     // @arc4.abimethod()
     // def verify_put_uint64(self, a: Account, b: Bytes, c: UInt64) -> None:
     proto 3 0
-    // tests/artifacts/StateOps/contract.py:397
+    // tests/artifacts/StateOps/contract.py:421
     // op.AppLocal.put(a, b, c)
     frame_dig -3
     frame_dig -2
@@ -406,11 +393,11 @@ verify_put_uint64:
 
 // tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_bytes(a: bytes, b: bytes, c: bytes) -> void:
 verify_put_bytes:
-    // tests/artifacts/StateOps/contract.py:399-400
+    // tests/artifacts/StateOps/contract.py:423-424
     // @arc4.abimethod()
     // def verify_put_bytes(self, a: Account, b: Bytes, c: Bytes) -> None:
     proto 3 0
-    // tests/artifacts/StateOps/contract.py:401
+    // tests/artifacts/StateOps/contract.py:425
     // op.AppLocal.put(a, b, c)
     frame_dig -3
     frame_dig -2
diff --git a/tests/artifacts/StateOps/data/StateAppLocalContract.arc32.json b/tests/artifacts/StateOps/data/StateAppLocalContract.arc32.json
index f5ed19a..7f46fa6 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAppLocalContract.arc32.json
@@ -47,8 +47,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.StateAppLocalContract.approval_program:
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@13
    method "opt_in()void"
    method "verify_get_bytes(account,byte[])byte[]"
    method "verify_get_uint64(account,byte[])uint64"
    method "verify_get_ex_bytes(account,application,byte[])byte[]"
    method "verify_get_ex_uint64(account,application,byte[])uint64"
    method "verify_delete(account,byte[])void"
    method "verify_exists(account,byte[])bool"
    method "verify_put_uint64(account,byte[],uint64)void"
    method "verify_put_bytes(account,byte[],byte[])void"
    txna ApplicationArgs 0
    match main_opt_in_route@2 main_verify_get_bytes_route@3 main_verify_get_uint64_route@4 main_verify_get_ex_bytes_route@5 main_verify_get_ex_uint64_route@6 main_verify_delete_route@7 main_verify_exists_route@8 main_verify_put_uint64_route@9 main_verify_put_bytes_route@10
    err // reject transaction

main_opt_in_route@2:
    // tests/artifacts/StateOps/contract.py:361
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    int OptIn
    ==
    assert // OnCompletion is OptIn
    txn ApplicationID
    assert // is not creating
    callsub opt_in
    int 1
    return

main_verify_get_bytes_route@3:
    // tests/artifacts/StateOps/contract.py:366
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:366
    // @arc4.abimethod()
    callsub verify_get_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_get_uint64_route@4:
    // tests/artifacts/StateOps/contract.py:371
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:371
    // @arc4.abimethod()
    callsub verify_get_uint64
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_get_ex_bytes_route@5:
    // tests/artifacts/StateOps/contract.py:376
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:376
    // @arc4.abimethod()
    callsub verify_get_ex_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_get_ex_uint64_route@6:
    // tests/artifacts/StateOps/contract.py:381
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:381
    // @arc4.abimethod()
    callsub verify_get_ex_uint64
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_delete_route@7:
    // tests/artifacts/StateOps/contract.py:386
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:386
    // @arc4.abimethod()
    callsub verify_delete
    int 1
    return

main_verify_exists_route@8:
    // tests/artifacts/StateOps/contract.py:390
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:390
    // @arc4.abimethod()
    callsub verify_exists
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_put_uint64_route@9:
    // tests/artifacts/StateOps/contract.py:395
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/StateOps/contract.py:395
    // @arc4.abimethod()
    callsub verify_put_uint64
    int 1
    return

main_verify_put_bytes_route@10:
    // tests/artifacts/StateOps/contract.py:399
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:399
    // @arc4.abimethod()
    callsub verify_put_bytes
    int 1
    return

main_bare_routing@13:
    // tests/artifacts/StateOps/contract.py:349
    // class StateAppLocalContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:361-362
    // @arc4.abimethod(allow_actions=["OptIn"])
    // def opt_in(self) -> None:
    proto 0 0
    // tests/artifacts/StateOps/contract.py:363
    // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes")
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:358
    // key="local_bytes",
    byte "local_bytes"
    // tests/artifacts/StateOps/contract.py:363
    // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes")
    byte 0x64756d6d795f6279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:364
    // self.local_uint64[Global.creator_address] = UInt64(999)
    global CreatorAddress
    // tests/artifacts/StateOps/contract.py:353
    // key="local_uint64",
    byte "local_uint64"
    // tests/artifacts/StateOps/contract.py:364
    // self.local_uint64[Global.creator_address] = UInt64(999)
    int 999
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_bytes(a: bytes, b: bytes) -> bytes:
verify_get_bytes:
    // tests/artifacts/StateOps/contract.py:366-367
    // @arc4.abimethod()
    // def verify_get_bytes(self, a: Account, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/StateOps/contract.py:368
    // value = op.AppLocal.get_bytes(a, b)
    frame_dig -2
    frame_dig -1
    app_local_get
    // tests/artifacts/StateOps/contract.py:369
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_uint64(a: bytes, b: bytes) -> uint64:
verify_get_uint64:
    // tests/artifacts/StateOps/contract.py:371-372
    // @arc4.abimethod()
    // def verify_get_uint64(self, a: Account, b: Bytes) -> UInt64:
    proto 2 1
    // tests/artifacts/StateOps/contract.py:373
    // value = op.AppLocal.get_uint64(a, b)
    frame_dig -2
    frame_dig -1
    app_local_get
    // tests/artifacts/StateOps/contract.py:374
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_bytes(a: bytes, b: uint64, c: bytes) -> bytes:
verify_get_ex_bytes:
    // tests/artifacts/StateOps/contract.py:376-377
    // @arc4.abimethod()
    // def verify_get_ex_bytes(self, a: Account, b: Application, c: Bytes) -> Bytes:
    proto 3 1
    // tests/artifacts/StateOps/contract.py:378
    // value, _val = op.AppLocal.get_ex_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_get_ex
    pop
    // tests/artifacts/StateOps/contract.py:379
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_uint64(a: bytes, b: uint64, c: bytes) -> uint64:
verify_get_ex_uint64:
    // tests/artifacts/StateOps/contract.py:381-382
    // @arc4.abimethod()
    // def verify_get_ex_uint64(self, a: Account, b: Application, c: Bytes) -> UInt64:
    proto 3 1
    // tests/artifacts/StateOps/contract.py:383
    // value, _val = op.AppLocal.get_ex_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_get_ex
    pop
    // tests/artifacts/StateOps/contract.py:384
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_delete(a: bytes, b: bytes) -> void:
verify_delete:
    // tests/artifacts/StateOps/contract.py:386-387
    // @arc4.abimethod()
    // def verify_delete(self, a: Account, b: Bytes) -> None:
    proto 2 0
    // tests/artifacts/StateOps/contract.py:388
    // op.AppLocal.delete(a, b)
    frame_dig -2
    frame_dig -1
    app_local_del
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_exists(a: bytes, b: bytes) -> uint64:
verify_exists:
    // tests/artifacts/StateOps/contract.py:390-391
    // @arc4.abimethod()
    // def verify_exists(self, a: Account, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/StateOps/contract.py:392
    // _value, exists = op.AppLocal.get_ex_uint64(a, 0, b)
    frame_dig -2
    int 0
    frame_dig -1
    app_local_get_ex
    bury 1
    // tests/artifacts/StateOps/contract.py:393
    // return exists
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_uint64(a: bytes, b: bytes, c: uint64) -> void:
verify_put_uint64:
    // tests/artifacts/StateOps/contract.py:395-396
    // @arc4.abimethod()
    // def verify_put_uint64(self, a: Account, b: Bytes, c: UInt64) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:397
    // op.AppLocal.put(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_bytes(a: bytes, b: bytes, c: bytes) -> void:
verify_put_bytes:
    // tests/artifacts/StateOps/contract.py:399-400
    // @arc4.abimethod()
    // def verify_put_bytes(self, a: Account, b: Bytes, c: Bytes) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:401
    // op.AppLocal.put(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_put
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBMb2NhbENvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6MzQ5CiAgICAvLyBjbGFzcyBTdGF0ZUFwcExvY2FsQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "approval": "#pragma version 10
#pragma typetrack false

// tests.artifacts.StateOps.contract.StateAppLocalContract.__algopy_entrypoint_with_init() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@14
    pushbytess 0x30c6d58a 0x937b5e13 0x8d742b86 0x7a6d0b59 0x594ff1d9 0x95a31727 0xaa1f4792 0x46245287 0x7f0fdfdd // method "opt_in()void", method "verify_get_bytes(account,byte[])byte[]", method "verify_get_uint64(account,byte[])uint64", method "verify_get_ex_bytes(account,application,byte[])byte[]", method "verify_get_ex_uint64(account,application,byte[])uint64", method "verify_delete(account,byte[])void", method "verify_exists(account,byte[])bool", method "verify_put_uint64(account,byte[],uint64)void", method "verify_put_bytes(account,byte[],byte[])void"
    txna ApplicationArgs 0
    match main_opt_in_route@5 main_verify_get_bytes_route@6 main_verify_get_uint64_route@7 main_verify_get_ex_bytes_route@8 main_verify_get_ex_uint64_route@9 main_verify_delete_route@10 main_verify_exists_route@11 main_verify_put_uint64_route@12 main_verify_put_bytes_route@13

main_after_if_else@16:
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    intc_1 // 0
    return

main_verify_put_bytes_route@13:
    // tests/artifacts/StateOps/contract.py:423
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:423
    // @arc4.abimethod()
    callsub verify_put_bytes
    intc_0 // 1
    return

main_verify_put_uint64_route@12:
    // tests/artifacts/StateOps/contract.py:419
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/StateOps/contract.py:419
    // @arc4.abimethod()
    callsub verify_put_uint64
    intc_0 // 1
    return

main_verify_exists_route@11:
    // tests/artifacts/StateOps/contract.py:414
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:414
    // @arc4.abimethod()
    callsub verify_exists
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_delete_route@10:
    // tests/artifacts/StateOps/contract.py:410
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:410
    // @arc4.abimethod()
    callsub verify_delete
    intc_0 // 1
    return

main_verify_get_ex_uint64_route@9:
    // tests/artifacts/StateOps/contract.py:405
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:405
    // @arc4.abimethod()
    callsub verify_get_ex_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_get_ex_bytes_route@8:
    // tests/artifacts/StateOps/contract.py:400
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    btoi
    txnas Applications
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/StateOps/contract.py:400
    // @arc4.abimethod()
    callsub verify_get_ex_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_get_uint64_route@7:
    // tests/artifacts/StateOps/contract.py:395
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:395
    // @arc4.abimethod()
    callsub verify_get_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_get_bytes_route@6:
    // tests/artifacts/StateOps/contract.py:390
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Accounts
    txna ApplicationArgs 2
    extract 2 0
    // tests/artifacts/StateOps/contract.py:390
    // @arc4.abimethod()
    callsub verify_get_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_opt_in_route@5:
    // tests/artifacts/StateOps/contract.py:385
    // @arc4.abimethod(allow_actions=["OptIn"])
    txn OnCompletion
    intc_0 // OptIn
    ==
    assert // OnCompletion is not OptIn
    txn ApplicationID
    assert // can only call when not creating
    callsub opt_in
    intc_0 // 1
    return

main_bare_routing@14:
    // tests/artifacts/StateOps/contract.py:373
    // class StateAppLocalContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@16
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppLocalContract.opt_in() -> void:
opt_in:
    // tests/artifacts/StateOps/contract.py:387
    // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes")
    global CreatorAddress
    pushbytess "local_bytes" 0x64756d6d795f6279746573 // "local_bytes", 0x64756d6d795f6279746573
    app_local_put
    // tests/artifacts/StateOps/contract.py:388
    // self.local_uint64[Global.creator_address] = UInt64(999)
    global CreatorAddress
    pushbytes "local_uint64"
    pushint 999 // 999
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_bytes(a: bytes, b: bytes) -> bytes:
verify_get_bytes:
    // tests/artifacts/StateOps/contract.py:390-391
    // @arc4.abimethod()
    // def verify_get_bytes(self, a: Account, b: Bytes) -> Bytes:
    proto 2 1
    // tests/artifacts/StateOps/contract.py:392
    // value = op.AppLocal.get_bytes(a, b)
    frame_dig -2
    frame_dig -1
    app_local_get
    // tests/artifacts/StateOps/contract.py:393
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_uint64(a: bytes, b: bytes) -> uint64:
verify_get_uint64:
    // tests/artifacts/StateOps/contract.py:395-396
    // @arc4.abimethod()
    // def verify_get_uint64(self, a: Account, b: Bytes) -> UInt64:
    proto 2 1
    // tests/artifacts/StateOps/contract.py:397
    // value = op.AppLocal.get_uint64(a, b)
    frame_dig -2
    frame_dig -1
    app_local_get
    // tests/artifacts/StateOps/contract.py:398
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_bytes(a: bytes, b: uint64, c: bytes) -> bytes:
verify_get_ex_bytes:
    // tests/artifacts/StateOps/contract.py:400-401
    // @arc4.abimethod()
    // def verify_get_ex_bytes(self, a: Account, b: Application, c: Bytes) -> Bytes:
    proto 3 1
    // tests/artifacts/StateOps/contract.py:402
    // value, _val = op.AppLocal.get_ex_bytes(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_get_ex
    pop
    // tests/artifacts/StateOps/contract.py:403
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_get_ex_uint64(a: bytes, b: uint64, c: bytes) -> uint64:
verify_get_ex_uint64:
    // tests/artifacts/StateOps/contract.py:405-406
    // @arc4.abimethod()
    // def verify_get_ex_uint64(self, a: Account, b: Application, c: Bytes) -> UInt64:
    proto 3 1
    // tests/artifacts/StateOps/contract.py:407
    // value, _val = op.AppLocal.get_ex_uint64(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_get_ex
    pop
    // tests/artifacts/StateOps/contract.py:408
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_delete(a: bytes, b: bytes) -> void:
verify_delete:
    // tests/artifacts/StateOps/contract.py:410-411
    // @arc4.abimethod()
    // def verify_delete(self, a: Account, b: Bytes) -> None:
    proto 2 0
    // tests/artifacts/StateOps/contract.py:412
    // op.AppLocal.delete(a, b)
    frame_dig -2
    frame_dig -1
    app_local_del
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_exists(a: bytes, b: bytes) -> uint64:
verify_exists:
    // tests/artifacts/StateOps/contract.py:414-415
    // @arc4.abimethod()
    // def verify_exists(self, a: Account, b: Bytes) -> bool:
    proto 2 1
    // tests/artifacts/StateOps/contract.py:416
    // _value, exists = op.AppLocal.get_ex_uint64(a, 0, b)
    frame_dig -2
    intc_1 // 0
    frame_dig -1
    app_local_get_ex
    bury 1
    // tests/artifacts/StateOps/contract.py:417
    // return exists
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_uint64(a: bytes, b: bytes, c: uint64) -> void:
verify_put_uint64:
    // tests/artifacts/StateOps/contract.py:419-420
    // @arc4.abimethod()
    // def verify_put_uint64(self, a: Account, b: Bytes, c: UInt64) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:421
    // op.AppLocal.put(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_put
    retsub


// tests.artifacts.StateOps.contract.StateAppLocalContract.verify_put_bytes(a: bytes, b: bytes, c: bytes) -> void:
verify_put_bytes:
    // tests/artifacts/StateOps/contract.py:423-424
    // @arc4.abimethod()
    // def verify_put_bytes(self, a: Account, b: Bytes, c: Bytes) -> None:
    proto 3 0
    // tests/artifacts/StateOps/contract.py:425
    // op.AppLocal.put(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    app_local_put
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAppLocalContract.clear.teal b/tests/artifacts/StateOps/data/StateAppLocalContract.clear.teal
index 573a8b4..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAppLocalContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppLocalContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:349
-    // class StateAppLocalContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAppLocalExContract.approval.teal b/tests/artifacts/StateOps/data/StateAppLocalExContract.approval.teal
index bd92746..4d08b0d 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalExContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAppLocalExContract.approval.teal
@@ -1,77 +1,67 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppLocalExContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:323
+// tests.artifacts.StateOps.contract.StateAppLocalExContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    // tests/artifacts/StateOps/contract.py:347
     // class StateAppLocalExContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@5
-    method "opt_in()void"
+    bz main_bare_routing@6
+    pushbytes 0x30c6d58a // method "opt_in()void"
     txna ApplicationArgs 0
-    match main_opt_in_route@2
-    err // reject transaction
+    match main_opt_in_route@5
 
-main_opt_in_route@2:
-    // tests/artifacts/StateOps/contract.py:340
+main_after_if_else@8:
+    // tests/artifacts/StateOps/contract.py:347
+    // class StateAppLocalExContract(ARC4Contract):
+    pushint 0 // 0
+    return
+
+main_opt_in_route@5:
+    // tests/artifacts/StateOps/contract.py:364
     // @arc4.abimethod(allow_actions=["OptIn"])
     txn OnCompletion
-    int OptIn
+    pushint 1 // OptIn
     ==
-    assert // OnCompletion is OptIn
+    assert // OnCompletion is not OptIn
     txn ApplicationID
-    assert // is not creating
+    assert // can only call when not creating
     callsub opt_in
-    int 1
+    pushint 1 // 1
     return
 
-main_bare_routing@5:
-    // tests/artifacts/StateOps/contract.py:323
+main_bare_routing@6:
+    // tests/artifacts/StateOps/contract.py:347
     // class StateAppLocalExContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@8
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    pushint 1 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.StateAppLocalExContract.opt_in() -> void:
 opt_in:
-    // tests/artifacts/StateOps/contract.py:340-341
-    // @arc4.abimethod(allow_actions=["OptIn"])
-    // def opt_in(self) -> None:
-    proto 0 0
-    // tests/artifacts/StateOps/contract.py:342
+    // tests/artifacts/StateOps/contract.py:366
     // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes_from_external_contract")
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:332
-    // key="local_bytes",
-    byte "local_bytes"
-    // tests/artifacts/StateOps/contract.py:342
-    // self.local_bytes[Global.creator_address] = Bytes(b"dummy_bytes_from_external_contract")
-    byte 0x64756d6d795f62797465735f66726f6d5f65787465726e616c5f636f6e7472616374
+    pushbytess "local_bytes" 0x64756d6d795f62797465735f66726f6d5f65787465726e616c5f636f6e7472616374 // "local_bytes", 0x64756d6d795f62797465735f66726f6d5f65787465726e616c5f636f6e7472616374
     app_local_put
-    // tests/artifacts/StateOps/contract.py:343
+    // tests/artifacts/StateOps/contract.py:367
     // self.local_uint64[Global.creator_address] = UInt64(99)
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:327
-    // key="local_uint64",
-    byte "local_uint64"
-    // tests/artifacts/StateOps/contract.py:343
-    // self.local_uint64[Global.creator_address] = UInt64(99)
-    int 99
+    pushbytes "local_uint64"
+    pushint 99 // 99
     app_local_put
-    // tests/artifacts/StateOps/contract.py:344
+    // tests/artifacts/StateOps/contract.py:368
     // self.local_arc4_bytes[Global.creator_address] = algopy.arc4.DynamicBytes(
     global CreatorAddress
-    // tests/artifacts/StateOps/contract.py:337
-    // key="local_arc4_bytes",
-    byte "local_arc4_bytes"
-    // tests/artifacts/StateOps/contract.py:344-346
+    // tests/artifacts/StateOps/contract.py:368-370
     // self.local_arc4_bytes[Global.creator_address] = algopy.arc4.DynamicBytes(
     //     b"dummy_arc4_bytes"
     // )
-    byte 0x001064756d6d795f617263345f6279746573
+    pushbytess "local_arc4_bytes" 0x001064756d6d795f617263345f6279746573 // "local_arc4_bytes", 0x001064756d6d795f617263345f6279746573
     app_local_put
     retsub
diff --git a/tests/artifacts/StateOps/data/StateAppLocalExContract.arc32.json b/tests/artifacts/StateOps/data/StateAppLocalExContract.arc32.json
index dc09a19..7ab584c 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalExContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAppLocalExContract.arc32.json
@@ -7,8 +7,8 @@
         }
     },
     "source": {
-        "approval": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBMb2NhbEV4Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTozMjMKICAgIC8vIGNsYXNzIFN0YXRlQXBwTG9jYWxFeENvbnRyYWN0KEFSQzRDb250cmFjdCk6CiAgICB0eG4gTnVtQXBwQXJncwogICAgYnogbWFpbl9iYXJlX3JvdXRpbmdANQogICAgbWV0aG9kICJvcHRfaW4oKXZvaWQiCiAgICB0eG5hIEFwcGxpY2F0aW9uQXJncyAwCiAgICBtYXRjaCBtYWluX29wdF9pbl9yb3V0ZUAyCiAgICBlcnIgLy8gcmVqZWN0IHRyYW5zYWN0aW9uCgptYWluX29wdF9pbl9yb3V0ZUAyOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjM0MAogICAgLy8gQGFyYzQuYWJpbWV0aG9kKGFsbG93X2FjdGlvbnM9WyJPcHRJbiJdKQogICAgdHhuIE9uQ29tcGxldGlvbgogICAgaW50IE9wdEluCiAgICA9PQogICAgYXNzZXJ0IC8vIE9uQ29tcGxldGlvbiBpcyBPcHRJbgogICAgdHhuIEFwcGxpY2F0aW9uSUQKICAgIGFzc2VydCAvLyBpcyBub3QgY3JlYXRpbmcKICAgIGNhbGxzdWIgb3B0X2luCiAgICBpbnQgMQogICAgcmV0dXJuCgptYWluX2JhcmVfcm91dGluZ0A1OgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjMyMwogICAgLy8gY2xhc3MgU3RhdGVBcHBMb2NhbEV4Q29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIHR4biBPbkNvbXBsZXRpb24KICAgICEKICAgIGFzc2VydCAvLyByZWplY3QgdHJhbnNhY3Rpb24KICAgIHR4biBBcHBsaWNhdGlvbklECiAgICAhCiAgICBhc3NlcnQgLy8gaXMgY3JlYXRpbmcKICAgIGludCAxCiAgICByZXR1cm4KCgovLyB0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBMb2NhbEV4Q29udHJhY3Qub3B0X2luKCkgLT4gdm9pZDoKb3B0X2luOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjM0MC0zNDEKICAgIC8vIEBhcmM0LmFiaW1ldGhvZChhbGxvd19hY3Rpb25zPVsiT3B0SW4iXSkKICAgIC8vIGRlZiBvcHRfaW4oc2VsZikgLT4gTm9uZToKICAgIHByb3RvIDAgMAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjM0MgogICAgLy8gc2VsZi5sb2NhbF9ieXRlc1tHbG9iYWwuY3JlYXRvcl9hZGRyZXNzXSA9IEJ5dGVzKGIiZHVtbXlfYnl0ZXNfZnJvbV9leHRlcm5hbF9jb250cmFjdCIpCiAgICBnbG9iYWwgQ3JlYXRvckFkZHJlc3MKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTozMzIKICAgIC8vIGtleT0ibG9jYWxfYnl0ZXMiLAogICAgYnl0ZSAibG9jYWxfYnl0ZXMiCiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6MzQyCiAgICAvLyBzZWxmLmxvY2FsX2J5dGVzW0dsb2JhbC5jcmVhdG9yX2FkZHJlc3NdID0gQnl0ZXMoYiJkdW1teV9ieXRlc19mcm9tX2V4dGVybmFsX2NvbnRyYWN0IikKICAgIGJ5dGUgMHg2NDc1NmQ2ZDc5NWY2Mjc5NzQ2NTczNWY2NjcyNmY2ZDVmNjU3ODc0NjU3MjZlNjE2YzVmNjM2ZjZlNzQ3MjYxNjM3NAogICAgYXBwX2xvY2FsX3B1dAogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjM0MwogICAgLy8gc2VsZi5sb2NhbF91aW50NjRbR2xvYmFsLmNyZWF0b3JfYWRkcmVzc10gPSBVSW50NjQoOTkpCiAgICBnbG9iYWwgQ3JlYXRvckFkZHJlc3MKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTozMjcKICAgIC8vIGtleT0ibG9jYWxfdWludDY0IiwKICAgIGJ5dGUgImxvY2FsX3VpbnQ2NCIKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTozNDMKICAgIC8vIHNlbGYubG9jYWxfdWludDY0W0dsb2JhbC5jcmVhdG9yX2FkZHJlc3NdID0gVUludDY0KDk5KQogICAgaW50IDk5CiAgICBhcHBfbG9jYWxfcHV0CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6MzQ0CiAgICAvLyBzZWxmLmxvY2FsX2FyYzRfYnl0ZXNbR2xvYmFsLmNyZWF0b3JfYWRkcmVzc10gPSBhbGdvcHkuYXJjNC5EeW5hbWljQnl0ZXMoCiAgICBnbG9iYWwgQ3JlYXRvckFkZHJlc3MKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTozMzcKICAgIC8vIGtleT0ibG9jYWxfYXJjNF9ieXRlcyIsCiAgICBieXRlICJsb2NhbF9hcmM0X2J5dGVzIgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjM0NC0zNDYKICAgIC8vIHNlbGYubG9jYWxfYXJjNF9ieXRlc1tHbG9iYWwuY3JlYXRvcl9hZGRyZXNzXSA9IGFsZ29weS5hcmM0LkR5bmFtaWNCeXRlcygKICAgIC8vICAgICBiImR1bW15X2FyYzRfYnl0ZXMiCiAgICAvLyApCiAgICBieXRlIDB4MDAxMDY0NzU2ZDZkNzk1ZjYxNzI2MzM0NWY2Mjc5NzQ2NTczCiAgICBhcHBfbG9jYWxfcHV0CiAgICByZXRzdWIK",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBMb2NhbEV4Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbToKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9TdGF0ZU9wcy9jb250cmFjdC5weTozMjMKICAgIC8vIGNsYXNzIFN0YXRlQXBwTG9jYWxFeENvbnRyYWN0KEFSQzRDb250cmFjdCk6CiAgICBpbnQgMQogICAgcmV0dXJuCg=="
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAppLocalExContract.clear.teal b/tests/artifacts/StateOps/data/StateAppLocalExContract.clear.teal
index c4080e2..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAppLocalExContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAppLocalExContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppLocalExContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:323
-    // class StateAppLocalExContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAppParamsContract.approval.teal b/tests/artifacts/StateOps/data/StateAppParamsContract.approval.teal
index d7d91f2..3df3cd4 100644
--- a/tests/artifacts/StateOps/data/StateAppParamsContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAppParamsContract.approval.teal
@@ -1,547 +1,543 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppParamsContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:248
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1
+    bytecblock 0x151f7c75
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@13
-    method "verify_app_params_get_approval_program(application)byte[]"
-    method "verify_app_params_get_clear_state_program(application)byte[]"
-    method "verify_app_params_get_global_num_uint(application)uint64"
-    method "verify_app_params_get_global_num_byte_slice(application)uint64"
-    method "verify_app_params_get_local_num_uint(application)uint64"
-    method "verify_app_params_get_local_num_byte_slice(application)uint64"
-    method "verify_app_params_get_extra_program_pages(application)uint64"
-    method "verify_app_params_get_creator(application)address"
-    method "verify_app_params_get_address(application)address"
+    bz main_bare_routing@14
+    pushbytess 0x5e7b7d52 0xe29e30ee 0x58819099 0xca77b59b 0x53c0dd9b 0x5f000703 0xd77bd21f 0xa941a746 0xbd3e9eec // method "verify_app_params_get_approval_program(application)byte[]", method "verify_app_params_get_clear_state_program(application)byte[]", method "verify_app_params_get_global_num_uint(application)uint64", method "verify_app_params_get_global_num_byte_slice(application)uint64", method "verify_app_params_get_local_num_uint(application)uint64", method "verify_app_params_get_local_num_byte_slice(application)uint64", method "verify_app_params_get_extra_program_pages(application)uint64", method "verify_app_params_get_creator(application)address", method "verify_app_params_get_address(application)address"
     txna ApplicationArgs 0
-    match main_verify_app_params_get_approval_program_route@2 main_verify_app_params_get_clear_state_program_route@3 main_verify_app_params_get_global_num_uint_route@4 main_verify_app_params_get_global_num_byte_slice_route@5 main_verify_app_params_get_local_num_uint_route@6 main_verify_app_params_get_local_num_byte_slice_route@7 main_verify_app_params_get_extra_program_pages_route@8 main_verify_app_params_get_creator_route@9 main_verify_app_params_get_address_route@10
-    err // reject transaction
+    match main_verify_app_params_get_approval_program_route@3 main_verify_app_params_get_clear_state_program_route@4 main_verify_app_params_get_global_num_uint_route@5 main_verify_app_params_get_global_num_byte_slice_route@6 main_verify_app_params_get_local_num_uint_route@7 main_verify_app_params_get_local_num_byte_slice_route@8 main_verify_app_params_get_extra_program_pages_route@9 main_verify_app_params_get_creator_route@10 main_verify_app_params_get_address_route@11
 
-main_verify_app_params_get_approval_program_route@2:
-    // tests/artifacts/StateOps/contract.py:250
+main_after_if_else@18:
+    // tests/artifacts/StateOps/contract.py:272
+    // class StateAppParamsContract(ARC4Contract):
+    pushint 0 // 0
+    return
+
+main_verify_app_params_get_address_route@11:
+    // tests/artifacts/StateOps/contract.py:338
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:250
+    // tests/artifacts/StateOps/contract.py:338
     // @arc4.abimethod()
-    callsub verify_app_params_get_approval_program
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_app_params_get_address
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_clear_state_program_route@3:
-    // tests/artifacts/StateOps/contract.py:258
+main_verify_app_params_get_creator_route@10:
+    // tests/artifacts/StateOps/contract.py:330
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:258
+    // tests/artifacts/StateOps/contract.py:330
     // @arc4.abimethod()
-    callsub verify_app_params_get_clear_state_program
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_app_params_get_creator
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_global_num_uint_route@4:
-    // tests/artifacts/StateOps/contract.py:266
+main_verify_app_params_get_extra_program_pages_route@9:
+    // tests/artifacts/StateOps/contract.py:322
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:266
+    // tests/artifacts/StateOps/contract.py:322
     // @arc4.abimethod()
-    callsub verify_app_params_get_global_num_uint
+    callsub verify_app_params_get_extra_program_pages
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_global_num_byte_slice_route@5:
-    // tests/artifacts/StateOps/contract.py:274
+main_verify_app_params_get_local_num_byte_slice_route@8:
+    // tests/artifacts/StateOps/contract.py:314
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:274
+    // tests/artifacts/StateOps/contract.py:314
     // @arc4.abimethod()
-    callsub verify_app_params_get_global_num_byte_slice
+    callsub verify_app_params_get_local_num_byte_slice
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_local_num_uint_route@6:
-    // tests/artifacts/StateOps/contract.py:282
+main_verify_app_params_get_local_num_uint_route@7:
+    // tests/artifacts/StateOps/contract.py:306
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:282
+    // tests/artifacts/StateOps/contract.py:306
     // @arc4.abimethod()
     callsub verify_app_params_get_local_num_uint
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_local_num_byte_slice_route@7:
-    // tests/artifacts/StateOps/contract.py:290
+main_verify_app_params_get_global_num_byte_slice_route@6:
+    // tests/artifacts/StateOps/contract.py:298
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:290
+    // tests/artifacts/StateOps/contract.py:298
     // @arc4.abimethod()
-    callsub verify_app_params_get_local_num_byte_slice
+    callsub verify_app_params_get_global_num_byte_slice
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_extra_program_pages_route@8:
-    // tests/artifacts/StateOps/contract.py:298
+main_verify_app_params_get_global_num_uint_route@5:
+    // tests/artifacts/StateOps/contract.py:290
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:298
+    // tests/artifacts/StateOps/contract.py:290
     // @arc4.abimethod()
-    callsub verify_app_params_get_extra_program_pages
+    callsub verify_app_params_get_global_num_uint
     itob
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_creator_route@9:
-    // tests/artifacts/StateOps/contract.py:306
+main_verify_app_params_get_clear_state_program_route@4:
+    // tests/artifacts/StateOps/contract.py:282
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:306
+    // tests/artifacts/StateOps/contract.py:282
     // @arc4.abimethod()
-    callsub verify_app_params_get_creator
-    byte 0x151f7c75
+    callsub verify_app_params_get_clear_state_program
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_app_params_get_address_route@10:
-    // tests/artifacts/StateOps/contract.py:314
+main_verify_app_params_get_approval_program_route@3:
+    // tests/artifacts/StateOps/contract.py:274
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:248
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Applications
-    // tests/artifacts/StateOps/contract.py:314
+    // tests/artifacts/StateOps/contract.py:274
     // @arc4.abimethod()
-    callsub verify_app_params_get_address
-    byte 0x151f7c75
+    callsub verify_app_params_get_approval_program
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@13:
-    // tests/artifacts/StateOps/contract.py:248
+main_bare_routing@14:
+    // tests/artifacts/StateOps/contract.py:272
     // class StateAppParamsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@18
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_approval_program(a: uint64) -> bytes:
 verify_app_params_get_approval_program:
-    // tests/artifacts/StateOps/contract.py:250-251
+    // tests/artifacts/StateOps/contract.py:274-275
     // @arc4.abimethod()
     // def verify_app_params_get_approval_program(self, a: Application) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:252
+    // tests/artifacts/StateOps/contract.py:276
     // value, exists = op.AppParamsGet.app_approval_program(a)
     frame_dig -1
     app_params_get AppApprovalProgram
-    swap
-    // tests/artifacts/StateOps/contract.py:253
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:277
     // value_index, exists_index = op.AppParamsGet.app_approval_program(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppApprovalProgram
-    cover 2
-    // tests/artifacts/StateOps/contract.py:254
+    // tests/artifacts/StateOps/contract.py:278
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:255
+    // tests/artifacts/StateOps/contract.py:279
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:256
+    // tests/artifacts/StateOps/contract.py:280
     // return value
     retsub
 
 
-// tests.artifacts.StateOps.contract._get_1st_ref_index() -> uint64:
-_get_1st_ref_index:
-    // tests/artifacts/StateOps/contract.py:19-20
-    // @subroutine
-    // def _get_1st_ref_index() -> UInt64:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:21
-    // return op.btoi(Txn.application_args(1))
-    txna ApplicationArgs 1
-    btoi
-    retsub
-
-
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_clear_state_program(a: uint64) -> bytes:
 verify_app_params_get_clear_state_program:
-    // tests/artifacts/StateOps/contract.py:258-259
+    // tests/artifacts/StateOps/contract.py:282-283
     // @arc4.abimethod()
     // def verify_app_params_get_clear_state_program(self, a: Application) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:260
+    // tests/artifacts/StateOps/contract.py:284
     // value, exists = op.AppParamsGet.app_clear_state_program(a)
     frame_dig -1
     app_params_get AppClearStateProgram
-    swap
-    // tests/artifacts/StateOps/contract.py:261
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:285
     // value_index, exists_index = op.AppParamsGet.app_clear_state_program(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppClearStateProgram
-    cover 2
-    // tests/artifacts/StateOps/contract.py:262
+    // tests/artifacts/StateOps/contract.py:286
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:263
+    // tests/artifacts/StateOps/contract.py:287
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:264
+    // tests/artifacts/StateOps/contract.py:288
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_uint(a: uint64) -> uint64:
 verify_app_params_get_global_num_uint:
-    // tests/artifacts/StateOps/contract.py:266-267
+    // tests/artifacts/StateOps/contract.py:290-291
     // @arc4.abimethod()
     // def verify_app_params_get_global_num_uint(self, a: Application) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:268
+    // tests/artifacts/StateOps/contract.py:292
     // value, exists = op.AppParamsGet.app_global_num_uint(a)
     frame_dig -1
     app_params_get AppGlobalNumUint
-    swap
-    // tests/artifacts/StateOps/contract.py:269
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:293
     // value_index, exists_index = op.AppParamsGet.app_global_num_uint(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppGlobalNumUint
-    cover 2
-    // tests/artifacts/StateOps/contract.py:270
+    // tests/artifacts/StateOps/contract.py:294
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:271
+    // tests/artifacts/StateOps/contract.py:295
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:272
+    // tests/artifacts/StateOps/contract.py:296
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_byte_slice(a: uint64) -> uint64:
 verify_app_params_get_global_num_byte_slice:
-    // tests/artifacts/StateOps/contract.py:274-275
+    // tests/artifacts/StateOps/contract.py:298-299
     // @arc4.abimethod()
     // def verify_app_params_get_global_num_byte_slice(self, a: Application) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:276
+    // tests/artifacts/StateOps/contract.py:300
     // value, exists = op.AppParamsGet.app_global_num_byte_slice(a)
     frame_dig -1
     app_params_get AppGlobalNumByteSlice
-    swap
-    // tests/artifacts/StateOps/contract.py:277
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:301
     // value_index, exists_index = op.AppParamsGet.app_global_num_byte_slice(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppGlobalNumByteSlice
-    cover 2
-    // tests/artifacts/StateOps/contract.py:278
+    // tests/artifacts/StateOps/contract.py:302
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:279
+    // tests/artifacts/StateOps/contract.py:303
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:280
+    // tests/artifacts/StateOps/contract.py:304
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_uint(a: uint64) -> uint64:
 verify_app_params_get_local_num_uint:
-    // tests/artifacts/StateOps/contract.py:282-283
+    // tests/artifacts/StateOps/contract.py:306-307
     // @arc4.abimethod()
     // def verify_app_params_get_local_num_uint(self, a: Application) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:284
+    // tests/artifacts/StateOps/contract.py:308
     // value, exists = op.AppParamsGet.app_local_num_uint(a)
     frame_dig -1
     app_params_get AppLocalNumUint
-    swap
-    // tests/artifacts/StateOps/contract.py:285
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:309
     // value_index, exists_index = op.AppParamsGet.app_local_num_uint(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppLocalNumUint
-    cover 2
-    // tests/artifacts/StateOps/contract.py:286
+    // tests/artifacts/StateOps/contract.py:310
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:287
+    // tests/artifacts/StateOps/contract.py:311
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:288
+    // tests/artifacts/StateOps/contract.py:312
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_byte_slice(a: uint64) -> uint64:
 verify_app_params_get_local_num_byte_slice:
-    // tests/artifacts/StateOps/contract.py:290-291
+    // tests/artifacts/StateOps/contract.py:314-315
     // @arc4.abimethod()
     // def verify_app_params_get_local_num_byte_slice(self, a: Application) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:292
+    // tests/artifacts/StateOps/contract.py:316
     // value, exists = op.AppParamsGet.app_local_num_byte_slice(a)
     frame_dig -1
     app_params_get AppLocalNumByteSlice
-    swap
-    // tests/artifacts/StateOps/contract.py:293
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:317
     // value_index, exists_index = op.AppParamsGet.app_local_num_byte_slice(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppLocalNumByteSlice
-    cover 2
-    // tests/artifacts/StateOps/contract.py:294
+    // tests/artifacts/StateOps/contract.py:318
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:295
+    // tests/artifacts/StateOps/contract.py:319
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:296
+    // tests/artifacts/StateOps/contract.py:320
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_extra_program_pages(a: uint64) -> uint64:
 verify_app_params_get_extra_program_pages:
-    // tests/artifacts/StateOps/contract.py:298-299
+    // tests/artifacts/StateOps/contract.py:322-323
     // @arc4.abimethod()
     // def verify_app_params_get_extra_program_pages(self, a: Application) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:300
+    // tests/artifacts/StateOps/contract.py:324
     // value, exists = op.AppParamsGet.app_extra_program_pages(a)
     frame_dig -1
     app_params_get AppExtraProgramPages
-    swap
-    // tests/artifacts/StateOps/contract.py:301
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:325
     // value_index, exists_index = op.AppParamsGet.app_extra_program_pages(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppExtraProgramPages
-    cover 2
-    // tests/artifacts/StateOps/contract.py:302
+    // tests/artifacts/StateOps/contract.py:326
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:303
+    // tests/artifacts/StateOps/contract.py:327
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:304
+    // tests/artifacts/StateOps/contract.py:328
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_creator(a: uint64) -> bytes:
 verify_app_params_get_creator:
-    // tests/artifacts/StateOps/contract.py:306-307
+    // tests/artifacts/StateOps/contract.py:330-331
     // @arc4.abimethod()
     // def verify_app_params_get_creator(self, a: Application) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:308
+    // tests/artifacts/StateOps/contract.py:332
     // value, exists = op.AppParamsGet.app_creator(a)
     frame_dig -1
     app_params_get AppCreator
-    swap
-    // tests/artifacts/StateOps/contract.py:309
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:333
     // value_index, exists_index = op.AppParamsGet.app_creator(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppCreator
-    cover 2
-    // tests/artifacts/StateOps/contract.py:310
+    // tests/artifacts/StateOps/contract.py:334
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:311
+    // tests/artifacts/StateOps/contract.py:335
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:312
+    // tests/artifacts/StateOps/contract.py:336
     // return arc4.Address(value)
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_address(a: uint64) -> bytes:
 verify_app_params_get_address:
-    // tests/artifacts/StateOps/contract.py:314-315
+    // tests/artifacts/StateOps/contract.py:338-339
     // @arc4.abimethod()
     // def verify_app_params_get_address(self, a: Application) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:316
+    // tests/artifacts/StateOps/contract.py:340
     // value, exists = op.AppParamsGet.app_address(a)
     frame_dig -1
     app_params_get AppAddress
-    swap
-    // tests/artifacts/StateOps/contract.py:317
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:341
     // value_index, exists_index = op.AppParamsGet.app_address(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     app_params_get AppAddress
-    cover 2
-    // tests/artifacts/StateOps/contract.py:318
+    // tests/artifacts/StateOps/contract.py:342
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:319
+    // tests/artifacts/StateOps/contract.py:343
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:320
+    // tests/artifacts/StateOps/contract.py:344
     // return arc4.Address(value)
     retsub
diff --git a/tests/artifacts/StateOps/data/StateAppParamsContract.arc32.json b/tests/artifacts/StateOps/data/StateAppParamsContract.arc32.json
index 76ab2a1..04f317d 100644
--- a/tests/artifacts/StateOps/data/StateAppParamsContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAppParamsContract.arc32.json
@@ -47,8 +47,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.StateAppParamsContract.approval_program:
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@13
    method "verify_app_params_get_approval_program(application)byte[]"
    method "verify_app_params_get_clear_state_program(application)byte[]"
    method "verify_app_params_get_global_num_uint(application)uint64"
    method "verify_app_params_get_global_num_byte_slice(application)uint64"
    method "verify_app_params_get_local_num_uint(application)uint64"
    method "verify_app_params_get_local_num_byte_slice(application)uint64"
    method "verify_app_params_get_extra_program_pages(application)uint64"
    method "verify_app_params_get_creator(application)address"
    method "verify_app_params_get_address(application)address"
    txna ApplicationArgs 0
    match main_verify_app_params_get_approval_program_route@2 main_verify_app_params_get_clear_state_program_route@3 main_verify_app_params_get_global_num_uint_route@4 main_verify_app_params_get_global_num_byte_slice_route@5 main_verify_app_params_get_local_num_uint_route@6 main_verify_app_params_get_local_num_byte_slice_route@7 main_verify_app_params_get_extra_program_pages_route@8 main_verify_app_params_get_creator_route@9 main_verify_app_params_get_address_route@10
    err // reject transaction

main_verify_app_params_get_approval_program_route@2:
    // tests/artifacts/StateOps/contract.py:250
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:250
    // @arc4.abimethod()
    callsub verify_app_params_get_approval_program
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_clear_state_program_route@3:
    // tests/artifacts/StateOps/contract.py:258
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:258
    // @arc4.abimethod()
    callsub verify_app_params_get_clear_state_program
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_global_num_uint_route@4:
    // tests/artifacts/StateOps/contract.py:266
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:266
    // @arc4.abimethod()
    callsub verify_app_params_get_global_num_uint
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_global_num_byte_slice_route@5:
    // tests/artifacts/StateOps/contract.py:274
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:274
    // @arc4.abimethod()
    callsub verify_app_params_get_global_num_byte_slice
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_local_num_uint_route@6:
    // tests/artifacts/StateOps/contract.py:282
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:282
    // @arc4.abimethod()
    callsub verify_app_params_get_local_num_uint
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_local_num_byte_slice_route@7:
    // tests/artifacts/StateOps/contract.py:290
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:290
    // @arc4.abimethod()
    callsub verify_app_params_get_local_num_byte_slice
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_extra_program_pages_route@8:
    // tests/artifacts/StateOps/contract.py:298
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:298
    // @arc4.abimethod()
    callsub verify_app_params_get_extra_program_pages
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_creator_route@9:
    // tests/artifacts/StateOps/contract.py:306
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:306
    // @arc4.abimethod()
    callsub verify_app_params_get_creator
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_app_params_get_address_route@10:
    // tests/artifacts/StateOps/contract.py:314
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:314
    // @arc4.abimethod()
    callsub verify_app_params_get_address
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@13:
    // tests/artifacts/StateOps/contract.py:248
    // class StateAppParamsContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_approval_program(a: uint64) -> bytes:
verify_app_params_get_approval_program:
    // tests/artifacts/StateOps/contract.py:250-251
    // @arc4.abimethod()
    // def verify_app_params_get_approval_program(self, a: Application) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:252
    // value, exists = op.AppParamsGet.app_approval_program(a)
    frame_dig -1
    app_params_get AppApprovalProgram
    swap
    // tests/artifacts/StateOps/contract.py:253
    // value_index, exists_index = op.AppParamsGet.app_approval_program(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppApprovalProgram
    cover 2
    // tests/artifacts/StateOps/contract.py:254
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:255
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:256
    // return value
    retsub


// tests.artifacts.StateOps.contract._get_1st_ref_index() -> uint64:
_get_1st_ref_index:
    // tests/artifacts/StateOps/contract.py:19-20
    // @subroutine
    // def _get_1st_ref_index() -> UInt64:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_clear_state_program(a: uint64) -> bytes:
verify_app_params_get_clear_state_program:
    // tests/artifacts/StateOps/contract.py:258-259
    // @arc4.abimethod()
    // def verify_app_params_get_clear_state_program(self, a: Application) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:260
    // value, exists = op.AppParamsGet.app_clear_state_program(a)
    frame_dig -1
    app_params_get AppClearStateProgram
    swap
    // tests/artifacts/StateOps/contract.py:261
    // value_index, exists_index = op.AppParamsGet.app_clear_state_program(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppClearStateProgram
    cover 2
    // tests/artifacts/StateOps/contract.py:262
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:263
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:264
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_uint(a: uint64) -> uint64:
verify_app_params_get_global_num_uint:
    // tests/artifacts/StateOps/contract.py:266-267
    // @arc4.abimethod()
    // def verify_app_params_get_global_num_uint(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:268
    // value, exists = op.AppParamsGet.app_global_num_uint(a)
    frame_dig -1
    app_params_get AppGlobalNumUint
    swap
    // tests/artifacts/StateOps/contract.py:269
    // value_index, exists_index = op.AppParamsGet.app_global_num_uint(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppGlobalNumUint
    cover 2
    // tests/artifacts/StateOps/contract.py:270
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:271
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:272
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_byte_slice(a: uint64) -> uint64:
verify_app_params_get_global_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:274-275
    // @arc4.abimethod()
    // def verify_app_params_get_global_num_byte_slice(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:276
    // value, exists = op.AppParamsGet.app_global_num_byte_slice(a)
    frame_dig -1
    app_params_get AppGlobalNumByteSlice
    swap
    // tests/artifacts/StateOps/contract.py:277
    // value_index, exists_index = op.AppParamsGet.app_global_num_byte_slice(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppGlobalNumByteSlice
    cover 2
    // tests/artifacts/StateOps/contract.py:278
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:279
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:280
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_uint(a: uint64) -> uint64:
verify_app_params_get_local_num_uint:
    // tests/artifacts/StateOps/contract.py:282-283
    // @arc4.abimethod()
    // def verify_app_params_get_local_num_uint(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:284
    // value, exists = op.AppParamsGet.app_local_num_uint(a)
    frame_dig -1
    app_params_get AppLocalNumUint
    swap
    // tests/artifacts/StateOps/contract.py:285
    // value_index, exists_index = op.AppParamsGet.app_local_num_uint(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppLocalNumUint
    cover 2
    // tests/artifacts/StateOps/contract.py:286
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:287
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:288
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_byte_slice(a: uint64) -> uint64:
verify_app_params_get_local_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:290-291
    // @arc4.abimethod()
    // def verify_app_params_get_local_num_byte_slice(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:292
    // value, exists = op.AppParamsGet.app_local_num_byte_slice(a)
    frame_dig -1
    app_params_get AppLocalNumByteSlice
    swap
    // tests/artifacts/StateOps/contract.py:293
    // value_index, exists_index = op.AppParamsGet.app_local_num_byte_slice(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppLocalNumByteSlice
    cover 2
    // tests/artifacts/StateOps/contract.py:294
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:295
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:296
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_extra_program_pages(a: uint64) -> uint64:
verify_app_params_get_extra_program_pages:
    // tests/artifacts/StateOps/contract.py:298-299
    // @arc4.abimethod()
    // def verify_app_params_get_extra_program_pages(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:300
    // value, exists = op.AppParamsGet.app_extra_program_pages(a)
    frame_dig -1
    app_params_get AppExtraProgramPages
    swap
    // tests/artifacts/StateOps/contract.py:301
    // value_index, exists_index = op.AppParamsGet.app_extra_program_pages(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppExtraProgramPages
    cover 2
    // tests/artifacts/StateOps/contract.py:302
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:303
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:304
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_creator(a: uint64) -> bytes:
verify_app_params_get_creator:
    // tests/artifacts/StateOps/contract.py:306-307
    // @arc4.abimethod()
    // def verify_app_params_get_creator(self, a: Application) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:308
    // value, exists = op.AppParamsGet.app_creator(a)
    frame_dig -1
    app_params_get AppCreator
    swap
    // tests/artifacts/StateOps/contract.py:309
    // value_index, exists_index = op.AppParamsGet.app_creator(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppCreator
    cover 2
    // tests/artifacts/StateOps/contract.py:310
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:311
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:312
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_address(a: uint64) -> bytes:
verify_app_params_get_address:
    // tests/artifacts/StateOps/contract.py:314-315
    // @arc4.abimethod()
    // def verify_app_params_get_address(self, a: Application) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:316
    // value, exists = op.AppParamsGet.app_address(a)
    frame_dig -1
    app_params_get AppAddress
    swap
    // tests/artifacts/StateOps/contract.py:317
    // value_index, exists_index = op.AppParamsGet.app_address(_get_1st_ref_index())
    callsub _get_1st_ref_index
    app_params_get AppAddress
    cover 2
    // tests/artifacts/StateOps/contract.py:318
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:319
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:320
    // return arc4.Address(value)
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBcHBQYXJhbXNDb250cmFjdC5jbGVhcl9zdGF0ZV9wcm9ncmFtOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjI0OAogICAgLy8gY2xhc3MgU3RhdGVBcHBQYXJhbXNDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@14
    pushbytess 0x5e7b7d52 0xe29e30ee 0x58819099 0xca77b59b 0x53c0dd9b 0x5f000703 0xd77bd21f 0xa941a746 0xbd3e9eec // method "verify_app_params_get_approval_program(application)byte[]", method "verify_app_params_get_clear_state_program(application)byte[]", method "verify_app_params_get_global_num_uint(application)uint64", method "verify_app_params_get_global_num_byte_slice(application)uint64", method "verify_app_params_get_local_num_uint(application)uint64", method "verify_app_params_get_local_num_byte_slice(application)uint64", method "verify_app_params_get_extra_program_pages(application)uint64", method "verify_app_params_get_creator(application)address", method "verify_app_params_get_address(application)address"
    txna ApplicationArgs 0
    match main_verify_app_params_get_approval_program_route@3 main_verify_app_params_get_clear_state_program_route@4 main_verify_app_params_get_global_num_uint_route@5 main_verify_app_params_get_global_num_byte_slice_route@6 main_verify_app_params_get_local_num_uint_route@7 main_verify_app_params_get_local_num_byte_slice_route@8 main_verify_app_params_get_extra_program_pages_route@9 main_verify_app_params_get_creator_route@10 main_verify_app_params_get_address_route@11

main_after_if_else@18:
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    pushint 0 // 0
    return

main_verify_app_params_get_address_route@11:
    // tests/artifacts/StateOps/contract.py:338
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:338
    // @arc4.abimethod()
    callsub verify_app_params_get_address
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_creator_route@10:
    // tests/artifacts/StateOps/contract.py:330
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:330
    // @arc4.abimethod()
    callsub verify_app_params_get_creator
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_extra_program_pages_route@9:
    // tests/artifacts/StateOps/contract.py:322
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:322
    // @arc4.abimethod()
    callsub verify_app_params_get_extra_program_pages
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_local_num_byte_slice_route@8:
    // tests/artifacts/StateOps/contract.py:314
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:314
    // @arc4.abimethod()
    callsub verify_app_params_get_local_num_byte_slice
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_local_num_uint_route@7:
    // tests/artifacts/StateOps/contract.py:306
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:306
    // @arc4.abimethod()
    callsub verify_app_params_get_local_num_uint
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_global_num_byte_slice_route@6:
    // tests/artifacts/StateOps/contract.py:298
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:298
    // @arc4.abimethod()
    callsub verify_app_params_get_global_num_byte_slice
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_global_num_uint_route@5:
    // tests/artifacts/StateOps/contract.py:290
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:290
    // @arc4.abimethod()
    callsub verify_app_params_get_global_num_uint
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_clear_state_program_route@4:
    // tests/artifacts/StateOps/contract.py:282
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:282
    // @arc4.abimethod()
    callsub verify_app_params_get_clear_state_program
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_app_params_get_approval_program_route@3:
    // tests/artifacts/StateOps/contract.py:274
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Applications
    // tests/artifacts/StateOps/contract.py:274
    // @arc4.abimethod()
    callsub verify_app_params_get_approval_program
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@14:
    // tests/artifacts/StateOps/contract.py:272
    // class StateAppParamsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@18
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_approval_program(a: uint64) -> bytes:
verify_app_params_get_approval_program:
    // tests/artifacts/StateOps/contract.py:274-275
    // @arc4.abimethod()
    // def verify_app_params_get_approval_program(self, a: Application) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:276
    // value, exists = op.AppParamsGet.app_approval_program(a)
    frame_dig -1
    app_params_get AppApprovalProgram
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:277
    // value_index, exists_index = op.AppParamsGet.app_approval_program(_get_1st_ref_index())
    app_params_get AppApprovalProgram
    // tests/artifacts/StateOps/contract.py:278
    // 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:279
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:280
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_clear_state_program(a: uint64) -> bytes:
verify_app_params_get_clear_state_program:
    // tests/artifacts/StateOps/contract.py:282-283
    // @arc4.abimethod()
    // def verify_app_params_get_clear_state_program(self, a: Application) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:284
    // value, exists = op.AppParamsGet.app_clear_state_program(a)
    frame_dig -1
    app_params_get AppClearStateProgram
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:285
    // value_index, exists_index = op.AppParamsGet.app_clear_state_program(_get_1st_ref_index())
    app_params_get AppClearStateProgram
    // tests/artifacts/StateOps/contract.py:286
    // 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:287
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:288
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_uint(a: uint64) -> uint64:
verify_app_params_get_global_num_uint:
    // tests/artifacts/StateOps/contract.py:290-291
    // @arc4.abimethod()
    // def verify_app_params_get_global_num_uint(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:292
    // value, exists = op.AppParamsGet.app_global_num_uint(a)
    frame_dig -1
    app_params_get AppGlobalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:293
    // value_index, exists_index = op.AppParamsGet.app_global_num_uint(_get_1st_ref_index())
    app_params_get AppGlobalNumUint
    // tests/artifacts/StateOps/contract.py:294
    // 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:295
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:296
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_global_num_byte_slice(a: uint64) -> uint64:
verify_app_params_get_global_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:298-299
    // @arc4.abimethod()
    // def verify_app_params_get_global_num_byte_slice(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:300
    // value, exists = op.AppParamsGet.app_global_num_byte_slice(a)
    frame_dig -1
    app_params_get AppGlobalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:301
    // value_index, exists_index = op.AppParamsGet.app_global_num_byte_slice(_get_1st_ref_index())
    app_params_get AppGlobalNumByteSlice
    // tests/artifacts/StateOps/contract.py:302
    // 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:303
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:304
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_uint(a: uint64) -> uint64:
verify_app_params_get_local_num_uint:
    // tests/artifacts/StateOps/contract.py:306-307
    // @arc4.abimethod()
    // def verify_app_params_get_local_num_uint(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:308
    // value, exists = op.AppParamsGet.app_local_num_uint(a)
    frame_dig -1
    app_params_get AppLocalNumUint
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:309
    // value_index, exists_index = op.AppParamsGet.app_local_num_uint(_get_1st_ref_index())
    app_params_get AppLocalNumUint
    // tests/artifacts/StateOps/contract.py:310
    // 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:311
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:312
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_local_num_byte_slice(a: uint64) -> uint64:
verify_app_params_get_local_num_byte_slice:
    // tests/artifacts/StateOps/contract.py:314-315
    // @arc4.abimethod()
    // def verify_app_params_get_local_num_byte_slice(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:316
    // value, exists = op.AppParamsGet.app_local_num_byte_slice(a)
    frame_dig -1
    app_params_get AppLocalNumByteSlice
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:317
    // value_index, exists_index = op.AppParamsGet.app_local_num_byte_slice(_get_1st_ref_index())
    app_params_get AppLocalNumByteSlice
    // tests/artifacts/StateOps/contract.py:318
    // 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:319
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:320
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_extra_program_pages(a: uint64) -> uint64:
verify_app_params_get_extra_program_pages:
    // tests/artifacts/StateOps/contract.py:322-323
    // @arc4.abimethod()
    // def verify_app_params_get_extra_program_pages(self, a: Application) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:324
    // value, exists = op.AppParamsGet.app_extra_program_pages(a)
    frame_dig -1
    app_params_get AppExtraProgramPages
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:325
    // value_index, exists_index = op.AppParamsGet.app_extra_program_pages(_get_1st_ref_index())
    app_params_get AppExtraProgramPages
    // tests/artifacts/StateOps/contract.py:326
    // 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:327
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:328
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_creator(a: uint64) -> bytes:
verify_app_params_get_creator:
    // tests/artifacts/StateOps/contract.py:330-331
    // @arc4.abimethod()
    // def verify_app_params_get_creator(self, a: Application) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:332
    // value, exists = op.AppParamsGet.app_creator(a)
    frame_dig -1
    app_params_get AppCreator
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:333
    // value_index, exists_index = op.AppParamsGet.app_creator(_get_1st_ref_index())
    app_params_get AppCreator
    // tests/artifacts/StateOps/contract.py:334
    // 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:335
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:336
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAppParamsContract.verify_app_params_get_address(a: uint64) -> bytes:
verify_app_params_get_address:
    // tests/artifacts/StateOps/contract.py:338-339
    // @arc4.abimethod()
    // def verify_app_params_get_address(self, a: Application) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:340
    // value, exists = op.AppParamsGet.app_address(a)
    frame_dig -1
    app_params_get AppAddress
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:341
    // value_index, exists_index = op.AppParamsGet.app_address(_get_1st_ref_index())
    app_params_get AppAddress
    // tests/artifacts/StateOps/contract.py:342
    // 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:343
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:344
    // return arc4.Address(value)
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAppParamsContract.clear.teal b/tests/artifacts/StateOps/data/StateAppParamsContract.clear.teal
index d499707..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAppParamsContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAppParamsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAppParamsContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:248
-    // class StateAppParamsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAssetHoldingContract.approval.teal b/tests/artifacts/StateOps/data/StateAssetHoldingContract.approval.teal
index 6b077bd..de5092f 100644
--- a/tests/artifacts/StateOps/data/StateAssetHoldingContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAssetHoldingContract.approval.teal
@@ -1,25 +1,33 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAssetHoldingContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:138
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75
+    // tests/artifacts/StateOps/contract.py:162
     // class StateAssetHoldingContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@6
-    method "verify_asset_holding_get(account,asset)uint64"
-    method "verify_asset_frozen_get(account,asset)bool"
+    bz main_bare_routing@7
+    pushbytess 0x68301476 0x784c64eb // method "verify_asset_holding_get(account,asset)uint64", method "verify_asset_frozen_get(account,asset)bool"
     txna ApplicationArgs 0
-    match main_verify_asset_holding_get_route@2 main_verify_asset_frozen_get_route@3
-    err // reject transaction
+    match main_verify_asset_holding_get_route@3 main_verify_asset_frozen_get_route@4
 
-main_verify_asset_holding_get_route@2:
-    // tests/artifacts/StateOps/contract.py:139
+main_after_if_else@11:
+    // tests/artifacts/StateOps/contract.py:162
+    // class StateAssetHoldingContract(ARC4Contract):
+    intc_1 // 0
+    return
+
+main_verify_asset_frozen_get_route@4:
+    // tests/artifacts/StateOps/contract.py:168
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:138
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:162
     // class StateAssetHoldingContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
@@ -27,26 +35,29 @@ main_verify_asset_holding_get_route@2:
     txna ApplicationArgs 2
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:139
+    // tests/artifacts/StateOps/contract.py:168
     // @arc4.abimethod()
-    callsub verify_asset_holding_get
-    itob
-    byte 0x151f7c75
+    callsub verify_asset_frozen_get
+    pushbytes 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_frozen_get_route@3:
-    // tests/artifacts/StateOps/contract.py:144
+main_verify_asset_holding_get_route@3:
+    // tests/artifacts/StateOps/contract.py:163
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:138
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:162
     // class StateAssetHoldingContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
@@ -54,62 +65,58 @@ main_verify_asset_frozen_get_route@3:
     txna ApplicationArgs 2
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:144
+    // tests/artifacts/StateOps/contract.py:163
     // @arc4.abimethod()
-    callsub verify_asset_frozen_get
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_asset_holding_get
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@6:
-    // tests/artifacts/StateOps/contract.py:138
+main_bare_routing@7:
+    // tests/artifacts/StateOps/contract.py:162
     // class StateAssetHoldingContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@11
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.StateAssetHoldingContract.verify_asset_holding_get(a: bytes, b: uint64) -> uint64:
 verify_asset_holding_get:
-    // tests/artifacts/StateOps/contract.py:139-140
+    // tests/artifacts/StateOps/contract.py:163-164
     // @arc4.abimethod()
     // def verify_asset_holding_get(self, a: Account, b: Asset) -> UInt64:
     proto 2 1
-    // tests/artifacts/StateOps/contract.py:141
+    // tests/artifacts/StateOps/contract.py:165
     // balance, _val = op.AssetHoldingGet.asset_balance(a, b)
     frame_dig -2
     frame_dig -1
     asset_holding_get AssetBalance
     pop
-    // tests/artifacts/StateOps/contract.py:142
+    // tests/artifacts/StateOps/contract.py:166
     // return balance
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetHoldingContract.verify_asset_frozen_get(a: bytes, b: uint64) -> uint64:
 verify_asset_frozen_get:
-    // tests/artifacts/StateOps/contract.py:144-145
+    // tests/artifacts/StateOps/contract.py:168-169
     // @arc4.abimethod()
     // def verify_asset_frozen_get(self, a: Account, b: Asset) -> bool:
     proto 2 1
-    // tests/artifacts/StateOps/contract.py:146
+    // tests/artifacts/StateOps/contract.py:170
     // frozen, _val = op.AssetHoldingGet.asset_frozen(a, b)
     frame_dig -2
     frame_dig -1
     asset_holding_get AssetFrozen
     pop
-    // tests/artifacts/StateOps/contract.py:147
+    // tests/artifacts/StateOps/contract.py:171
     // return frozen
     retsub
diff --git a/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc32.json b/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc32.json
index a7b0497..26daec7 100644
--- a/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAssetHoldingContract.arc32.json
@@ -12,8 +12,8 @@
         }
     },
     "source": {
-        "approval": "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",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBc3NldEhvbGRpbmdDb250cmFjdC5jbGVhcl9zdGF0ZV9wcm9ncmFtOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL1N0YXRlT3BzL2NvbnRyYWN0LnB5OjEzOAogICAgLy8gY2xhc3MgU3RhdGVBc3NldEhvbGRpbmdDb250cmFjdChBUkM0Q29udHJhY3QpOgogICAgaW50IDEKICAgIHJldHVybgo="
+        "approval": "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",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAssetHoldingContract.clear.teal b/tests/artifacts/StateOps/data/StateAssetHoldingContract.clear.teal
index ec6efc8..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAssetHoldingContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAssetHoldingContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAssetHoldingContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:138
-    // class StateAssetHoldingContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return
diff --git a/tests/artifacts/StateOps/data/StateAssetParamsContract.approval.teal b/tests/artifacts/StateOps/data/StateAssetParamsContract.approval.teal
index b0cda94..227b140 100644
--- a/tests/artifacts/StateOps/data/StateAssetParamsContract.approval.teal
+++ b/tests/artifacts/StateOps/data/StateAssetParamsContract.approval.teal
@@ -1,725 +1,721 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAssetParamsContract.approval_program:
-    // tests/artifacts/StateOps/contract.py:150
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    intcblock 1 0
+    bytecblock 0x151f7c75
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txn NumAppArgs
-    bz main_bare_routing@16
-    method "verify_asset_params_get_total(asset)uint64"
-    method "verify_asset_params_get_decimals(asset)uint64"
-    method "verify_asset_params_get_default_frozen(asset)bool"
-    method "verify_asset_params_get_unit_name(asset)byte[]"
-    method "verify_asset_params_get_name(asset)byte[]"
-    method "verify_asset_params_get_url(asset)byte[]"
-    method "verify_asset_params_get_metadata_hash(asset)byte[]"
-    method "verify_asset_params_get_manager(asset)address"
-    method "verify_asset_params_get_reserve(asset)address"
-    method "verify_asset_params_get_freeze(asset)address"
-    method "verify_asset_params_get_clawback(asset)address"
-    method "verify_asset_params_get_creator(asset)address"
+    bz main_bare_routing@17
+    pushbytess 0xad719a6f 0x1d603013 0x9fb731cd 0x0f5a4911 0xf5b370c6 0xc7d6af74 0x6b71a263 0x3040ebc8 0x1d07e844 0x3e40cb50 0x340c786b 0xe38a9815 // method "verify_asset_params_get_total(asset)uint64", method "verify_asset_params_get_decimals(asset)uint64", method "verify_asset_params_get_default_frozen(asset)bool", method "verify_asset_params_get_unit_name(asset)byte[]", method "verify_asset_params_get_name(asset)byte[]", method "verify_asset_params_get_url(asset)byte[]", method "verify_asset_params_get_metadata_hash(asset)byte[]", method "verify_asset_params_get_manager(asset)address", method "verify_asset_params_get_reserve(asset)address", method "verify_asset_params_get_freeze(asset)address", method "verify_asset_params_get_clawback(asset)address", method "verify_asset_params_get_creator(asset)address"
     txna ApplicationArgs 0
-    match main_verify_asset_params_get_total_route@2 main_verify_asset_params_get_decimals_route@3 main_verify_asset_params_get_default_frozen_route@4 main_verify_asset_params_get_unit_name_route@5 main_verify_asset_params_get_name_route@6 main_verify_asset_params_get_url_route@7 main_verify_asset_params_get_metadata_hash_route@8 main_verify_asset_params_get_manager_route@9 main_verify_asset_params_get_reserve_route@10 main_verify_asset_params_get_freeze_route@11 main_verify_asset_params_get_clawback_route@12 main_verify_asset_params_get_creator_route@13
-    err // reject transaction
+    match main_verify_asset_params_get_total_route@3 main_verify_asset_params_get_decimals_route@4 main_verify_asset_params_get_default_frozen_route@5 main_verify_asset_params_get_unit_name_route@6 main_verify_asset_params_get_name_route@7 main_verify_asset_params_get_url_route@8 main_verify_asset_params_get_metadata_hash_route@9 main_verify_asset_params_get_manager_route@10 main_verify_asset_params_get_reserve_route@11 main_verify_asset_params_get_freeze_route@12 main_verify_asset_params_get_clawback_route@13 main_verify_asset_params_get_creator_route@14
 
-main_verify_asset_params_get_total_route@2:
-    // tests/artifacts/StateOps/contract.py:151
+main_after_if_else@21:
+    // tests/artifacts/StateOps/contract.py:174
+    // class StateAssetParamsContract(ARC4Contract):
+    intc_1 // 0
+    return
+
+main_verify_asset_params_get_creator_route@14:
+    // tests/artifacts/StateOps/contract.py:263
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:151
+    // tests/artifacts/StateOps/contract.py:263
     // @arc4.abimethod()
-    callsub verify_asset_params_get_total
-    itob
-    byte 0x151f7c75
+    callsub verify_asset_params_get_creator
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_decimals_route@3:
-    // tests/artifacts/StateOps/contract.py:159
+main_verify_asset_params_get_clawback_route@13:
+    // tests/artifacts/StateOps/contract.py:255
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:159
+    // tests/artifacts/StateOps/contract.py:255
     // @arc4.abimethod()
-    callsub verify_asset_params_get_decimals
-    itob
-    byte 0x151f7c75
+    callsub verify_asset_params_get_clawback
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_default_frozen_route@4:
-    // tests/artifacts/StateOps/contract.py:167
+main_verify_asset_params_get_freeze_route@12:
+    // tests/artifacts/StateOps/contract.py:247
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:167
+    // tests/artifacts/StateOps/contract.py:247
     // @arc4.abimethod()
-    callsub verify_asset_params_get_default_frozen
-    byte 0x00
-    int 0
-    uncover 2
-    setbit
-    byte 0x151f7c75
+    callsub verify_asset_params_get_freeze
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_unit_name_route@5:
-    // tests/artifacts/StateOps/contract.py:175
+main_verify_asset_params_get_reserve_route@11:
+    // tests/artifacts/StateOps/contract.py:239
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:175
+    // tests/artifacts/StateOps/contract.py:239
     // @arc4.abimethod()
-    callsub verify_asset_params_get_unit_name
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_asset_params_get_reserve
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_name_route@6:
-    // tests/artifacts/StateOps/contract.py:183
+main_verify_asset_params_get_manager_route@10:
+    // tests/artifacts/StateOps/contract.py:231
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:183
+    // tests/artifacts/StateOps/contract.py:231
     // @arc4.abimethod()
-    callsub verify_asset_params_get_name
-    dup
-    len
-    itob
-    extract 6 2
-    swap
-    concat
-    byte 0x151f7c75
+    callsub verify_asset_params_get_manager
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_url_route@7:
-    // tests/artifacts/StateOps/contract.py:191
+main_verify_asset_params_get_metadata_hash_route@9:
+    // tests/artifacts/StateOps/contract.py:223
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:191
+    // tests/artifacts/StateOps/contract.py:223
     // @arc4.abimethod()
-    callsub verify_asset_params_get_url
+    callsub verify_asset_params_get_metadata_hash
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_metadata_hash_route@8:
-    // tests/artifacts/StateOps/contract.py:199
+main_verify_asset_params_get_url_route@8:
+    // tests/artifacts/StateOps/contract.py:215
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:199
+    // tests/artifacts/StateOps/contract.py:215
     // @arc4.abimethod()
-    callsub verify_asset_params_get_metadata_hash
+    callsub verify_asset_params_get_url
     dup
     len
     itob
     extract 6 2
     swap
     concat
-    byte 0x151f7c75
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_manager_route@9:
+main_verify_asset_params_get_name_route@7:
     // tests/artifacts/StateOps/contract.py:207
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
     // tests/artifacts/StateOps/contract.py:207
     // @arc4.abimethod()
-    callsub verify_asset_params_get_manager
-    byte 0x151f7c75
+    callsub verify_asset_params_get_name
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_reserve_route@10:
-    // tests/artifacts/StateOps/contract.py:215
+main_verify_asset_params_get_unit_name_route@6:
+    // tests/artifacts/StateOps/contract.py:199
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:215
+    // tests/artifacts/StateOps/contract.py:199
     // @arc4.abimethod()
-    callsub verify_asset_params_get_reserve
-    byte 0x151f7c75
+    callsub verify_asset_params_get_unit_name
+    dup
+    len
+    itob
+    extract 6 2
+    swap
+    concat
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_freeze_route@11:
-    // tests/artifacts/StateOps/contract.py:223
+main_verify_asset_params_get_default_frozen_route@5:
+    // tests/artifacts/StateOps/contract.py:191
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:223
+    // tests/artifacts/StateOps/contract.py:191
     // @arc4.abimethod()
-    callsub verify_asset_params_get_freeze
-    byte 0x151f7c75
+    callsub verify_asset_params_get_default_frozen
+    pushbytes 0x00
+    intc_1 // 0
+    uncover 2
+    setbit
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_clawback_route@12:
-    // tests/artifacts/StateOps/contract.py:231
+main_verify_asset_params_get_decimals_route@4:
+    // tests/artifacts/StateOps/contract.py:183
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:231
+    // tests/artifacts/StateOps/contract.py:183
     // @arc4.abimethod()
-    callsub verify_asset_params_get_clawback
-    byte 0x151f7c75
+    callsub verify_asset_params_get_decimals
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_verify_asset_params_get_creator_route@13:
-    // tests/artifacts/StateOps/contract.py:239
+main_verify_asset_params_get_total_route@3:
+    // tests/artifacts/StateOps/contract.py:175
     // @arc4.abimethod()
     txn OnCompletion
     !
-    assert // OnCompletion is NoOp
+    assert // OnCompletion is not NoOp
     txn ApplicationID
-    assert // is not creating
-    // tests/artifacts/StateOps/contract.py:150
+    assert // can only call when not creating
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txna ApplicationArgs 1
     btoi
     txnas Assets
-    // tests/artifacts/StateOps/contract.py:239
+    // tests/artifacts/StateOps/contract.py:175
     // @arc4.abimethod()
-    callsub verify_asset_params_get_creator
-    byte 0x151f7c75
+    callsub verify_asset_params_get_total
+    itob
+    bytec_0 // 0x151f7c75
     swap
     concat
     log
-    int 1
+    intc_0 // 1
     return
 
-main_bare_routing@16:
-    // tests/artifacts/StateOps/contract.py:150
+main_bare_routing@17:
+    // tests/artifacts/StateOps/contract.py:174
     // class StateAssetParamsContract(ARC4Contract):
     txn OnCompletion
-    !
-    assert // reject transaction
+    bnz main_after_if_else@21
     txn ApplicationID
     !
-    assert // is creating
-    int 1
+    assert // can only call when creating
+    intc_0 // 1
     return
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_total(a: uint64) -> uint64:
 verify_asset_params_get_total:
-    // tests/artifacts/StateOps/contract.py:151-152
+    // tests/artifacts/StateOps/contract.py:175-176
     // @arc4.abimethod()
     // def verify_asset_params_get_total(self, a: Asset) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:153
+    // tests/artifacts/StateOps/contract.py:177
     // value, exists = op.AssetParamsGet.asset_total(a)
     frame_dig -1
     asset_params_get AssetTotal
-    swap
-    // tests/artifacts/StateOps/contract.py:154
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:178
     // value_index, exists_index = op.AssetParamsGet.asset_total(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetTotal
-    cover 2
-    // tests/artifacts/StateOps/contract.py:155
+    // tests/artifacts/StateOps/contract.py:179
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:156
+    // tests/artifacts/StateOps/contract.py:180
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:157
+    // tests/artifacts/StateOps/contract.py:181
     // return value
     retsub
 
 
-// tests.artifacts.StateOps.contract._get_1st_ref_index() -> uint64:
-_get_1st_ref_index:
-    // tests/artifacts/StateOps/contract.py:19-20
-    // @subroutine
-    // def _get_1st_ref_index() -> UInt64:
-    proto 0 1
-    // tests/artifacts/StateOps/contract.py:21
-    // return op.btoi(Txn.application_args(1))
-    txna ApplicationArgs 1
-    btoi
-    retsub
-
-
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_decimals(a: uint64) -> uint64:
 verify_asset_params_get_decimals:
-    // tests/artifacts/StateOps/contract.py:159-160
+    // tests/artifacts/StateOps/contract.py:183-184
     // @arc4.abimethod()
     // def verify_asset_params_get_decimals(self, a: Asset) -> UInt64:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:161
+    // tests/artifacts/StateOps/contract.py:185
     // value, exists = op.AssetParamsGet.asset_decimals(a)
     frame_dig -1
     asset_params_get AssetDecimals
-    swap
-    // tests/artifacts/StateOps/contract.py:162
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:186
     // value_index, exists_index = op.AssetParamsGet.asset_decimals(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetDecimals
-    cover 2
-    // tests/artifacts/StateOps/contract.py:163
+    // tests/artifacts/StateOps/contract.py:187
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:164
+    // tests/artifacts/StateOps/contract.py:188
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:165
+    // tests/artifacts/StateOps/contract.py:189
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_default_frozen(a: uint64) -> uint64:
 verify_asset_params_get_default_frozen:
-    // tests/artifacts/StateOps/contract.py:167-168
+    // tests/artifacts/StateOps/contract.py:191-192
     // @arc4.abimethod()
     // def verify_asset_params_get_default_frozen(self, a: Asset) -> bool:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:169
+    // tests/artifacts/StateOps/contract.py:193
     // value, exists = op.AssetParamsGet.asset_default_frozen(a)
     frame_dig -1
     asset_params_get AssetDefaultFrozen
-    swap
-    // tests/artifacts/StateOps/contract.py:170
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:194
     // value_index, exists_index = op.AssetParamsGet.asset_default_frozen(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetDefaultFrozen
-    cover 2
-    // tests/artifacts/StateOps/contract.py:171
+    // tests/artifacts/StateOps/contract.py:195
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:172
+    // tests/artifacts/StateOps/contract.py:196
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:173
+    // tests/artifacts/StateOps/contract.py:197
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_unit_name(a: uint64) -> bytes:
 verify_asset_params_get_unit_name:
-    // tests/artifacts/StateOps/contract.py:175-176
+    // tests/artifacts/StateOps/contract.py:199-200
     // @arc4.abimethod()
     // def verify_asset_params_get_unit_name(self, a: Asset) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:177
+    // tests/artifacts/StateOps/contract.py:201
     // value, exists = op.AssetParamsGet.asset_unit_name(a)
     frame_dig -1
     asset_params_get AssetUnitName
-    swap
-    // tests/artifacts/StateOps/contract.py:178
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:202
     // value_index, exists_index = op.AssetParamsGet.asset_unit_name(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetUnitName
-    cover 2
-    // tests/artifacts/StateOps/contract.py:179
+    // tests/artifacts/StateOps/contract.py:203
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:180
+    // tests/artifacts/StateOps/contract.py:204
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:181
+    // tests/artifacts/StateOps/contract.py:205
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_name(a: uint64) -> bytes:
 verify_asset_params_get_name:
-    // tests/artifacts/StateOps/contract.py:183-184
+    // tests/artifacts/StateOps/contract.py:207-208
     // @arc4.abimethod()
     // def verify_asset_params_get_name(self, a: Asset) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:185
+    // tests/artifacts/StateOps/contract.py:209
     // value, exists = op.AssetParamsGet.asset_name(a)
     frame_dig -1
     asset_params_get AssetName
-    swap
-    // tests/artifacts/StateOps/contract.py:186
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:210
     // value_index, exists_index = op.AssetParamsGet.asset_name(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetName
-    cover 2
-    // tests/artifacts/StateOps/contract.py:187
+    // tests/artifacts/StateOps/contract.py:211
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:188
+    // tests/artifacts/StateOps/contract.py:212
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:189
+    // tests/artifacts/StateOps/contract.py:213
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_url(a: uint64) -> bytes:
 verify_asset_params_get_url:
-    // tests/artifacts/StateOps/contract.py:191-192
+    // tests/artifacts/StateOps/contract.py:215-216
     // @arc4.abimethod()
     // def verify_asset_params_get_url(self, a: Asset) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:193
+    // tests/artifacts/StateOps/contract.py:217
     // value, exists = op.AssetParamsGet.asset_url(a)
     frame_dig -1
     asset_params_get AssetURL
-    swap
-    // tests/artifacts/StateOps/contract.py:194
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:218
     // value_index, exists_index = op.AssetParamsGet.asset_url(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetURL
-    cover 2
-    // tests/artifacts/StateOps/contract.py:195
+    // tests/artifacts/StateOps/contract.py:219
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:196
+    // tests/artifacts/StateOps/contract.py:220
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:197
+    // tests/artifacts/StateOps/contract.py:221
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_metadata_hash(a: uint64) -> bytes:
 verify_asset_params_get_metadata_hash:
-    // tests/artifacts/StateOps/contract.py:199-200
+    // tests/artifacts/StateOps/contract.py:223-224
     // @arc4.abimethod()
     // def verify_asset_params_get_metadata_hash(self, a: Asset) -> Bytes:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:201
+    // tests/artifacts/StateOps/contract.py:225
     // value, exists = op.AssetParamsGet.asset_metadata_hash(a)
     frame_dig -1
     asset_params_get AssetMetadataHash
-    swap
-    // tests/artifacts/StateOps/contract.py:202
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:226
     // value_index, exists_index = op.AssetParamsGet.asset_metadata_hash(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetMetadataHash
-    cover 2
-    // tests/artifacts/StateOps/contract.py:203
+    // tests/artifacts/StateOps/contract.py:227
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:204
+    // tests/artifacts/StateOps/contract.py:228
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:205
+    // tests/artifacts/StateOps/contract.py:229
     // return value
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_manager(a: uint64) -> bytes:
 verify_asset_params_get_manager:
-    // tests/artifacts/StateOps/contract.py:207-208
+    // tests/artifacts/StateOps/contract.py:231-232
     // @arc4.abimethod()
     // def verify_asset_params_get_manager(self, a: Asset) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:209
+    // tests/artifacts/StateOps/contract.py:233
     // value, exists = op.AssetParamsGet.asset_manager(a)
     frame_dig -1
     asset_params_get AssetManager
-    swap
-    // tests/artifacts/StateOps/contract.py:210
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:234
     // value_index, exists_index = op.AssetParamsGet.asset_manager(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetManager
-    cover 2
-    // tests/artifacts/StateOps/contract.py:211
+    // tests/artifacts/StateOps/contract.py:235
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:212
+    // tests/artifacts/StateOps/contract.py:236
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:213
+    // tests/artifacts/StateOps/contract.py:237
     // return arc4.Address(value)
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_reserve(a: uint64) -> bytes:
 verify_asset_params_get_reserve:
-    // tests/artifacts/StateOps/contract.py:215-216
+    // tests/artifacts/StateOps/contract.py:239-240
     // @arc4.abimethod()
     // def verify_asset_params_get_reserve(self, a: Asset) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:217
+    // tests/artifacts/StateOps/contract.py:241
     // value, exists = op.AssetParamsGet.asset_reserve(a)
     frame_dig -1
     asset_params_get AssetReserve
-    swap
-    // tests/artifacts/StateOps/contract.py:218
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:242
     // value_index, exists_index = op.AssetParamsGet.asset_reserve(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetReserve
-    cover 2
-    // tests/artifacts/StateOps/contract.py:219
+    // tests/artifacts/StateOps/contract.py:243
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:220
+    // tests/artifacts/StateOps/contract.py:244
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:221
+    // tests/artifacts/StateOps/contract.py:245
     // return arc4.Address(value)
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_freeze(a: uint64) -> bytes:
 verify_asset_params_get_freeze:
-    // tests/artifacts/StateOps/contract.py:223-224
+    // tests/artifacts/StateOps/contract.py:247-248
     // @arc4.abimethod()
     // def verify_asset_params_get_freeze(self, a: Asset) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:225
+    // tests/artifacts/StateOps/contract.py:249
     // value, exists = op.AssetParamsGet.asset_freeze(a)
     frame_dig -1
     asset_params_get AssetFreeze
-    swap
-    // tests/artifacts/StateOps/contract.py:226
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:250
     // value_index, exists_index = op.AssetParamsGet.asset_freeze(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetFreeze
-    cover 2
-    // tests/artifacts/StateOps/contract.py:227
+    // tests/artifacts/StateOps/contract.py:251
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:228
+    // tests/artifacts/StateOps/contract.py:252
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:229
+    // tests/artifacts/StateOps/contract.py:253
     // return arc4.Address(value)
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_clawback(a: uint64) -> bytes:
 verify_asset_params_get_clawback:
-    // tests/artifacts/StateOps/contract.py:231-232
+    // tests/artifacts/StateOps/contract.py:255-256
     // @arc4.abimethod()
     // def verify_asset_params_get_clawback(self, a: Asset) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:233
+    // tests/artifacts/StateOps/contract.py:257
     // value, exists = op.AssetParamsGet.asset_clawback(a)
     frame_dig -1
     asset_params_get AssetClawback
-    swap
-    // tests/artifacts/StateOps/contract.py:234
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:258
     // value_index, exists_index = op.AssetParamsGet.asset_clawback(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetClawback
-    cover 2
-    // tests/artifacts/StateOps/contract.py:235
+    // tests/artifacts/StateOps/contract.py:259
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:236
+    // tests/artifacts/StateOps/contract.py:260
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:237
+    // tests/artifacts/StateOps/contract.py:261
     // return arc4.Address(value)
     retsub
 
 
 // tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_creator(a: uint64) -> bytes:
 verify_asset_params_get_creator:
-    // tests/artifacts/StateOps/contract.py:239-240
+    // tests/artifacts/StateOps/contract.py:263-264
     // @arc4.abimethod()
     // def verify_asset_params_get_creator(self, a: Asset) -> arc4.Address:
     proto 1 1
-    // tests/artifacts/StateOps/contract.py:241
+    // tests/artifacts/StateOps/contract.py:265
     // value, exists = op.AssetParamsGet.asset_creator(a)
     frame_dig -1
     asset_params_get AssetCreator
-    swap
-    // tests/artifacts/StateOps/contract.py:242
+    // tests/artifacts/StateOps/contract.py:21
+    // return op.btoi(Txn.application_args(1))
+    txna ApplicationArgs 1
+    btoi
+    // tests/artifacts/StateOps/contract.py:266
     // value_index, exists_index = op.AssetParamsGet.asset_creator(_get_1st_ref_index())
-    callsub _get_1st_ref_index
     asset_params_get AssetCreator
-    cover 2
-    // tests/artifacts/StateOps/contract.py:243
+    // tests/artifacts/StateOps/contract.py:267
     // assert value == value_index, "expected value by index to match"
-    dig 1
+    dig 3
+    uncover 2
     ==
     assert // expected value by index to match
-    // tests/artifacts/StateOps/contract.py:244
+    // tests/artifacts/StateOps/contract.py:268
     // assert exists == exists_index, "expected exists by index to match"
-    cover 2
     ==
     assert // expected exists by index to match
-    // tests/artifacts/StateOps/contract.py:245
+    // tests/artifacts/StateOps/contract.py:269
     // return arc4.Address(value)
     retsub
diff --git a/tests/artifacts/StateOps/data/StateAssetParamsContract.arc32.json b/tests/artifacts/StateOps/data/StateAssetParamsContract.arc32.json
index 04e164b..446614a 100644
--- a/tests/artifacts/StateOps/data/StateAssetParamsContract.arc32.json
+++ b/tests/artifacts/StateOps/data/StateAssetParamsContract.arc32.json
@@ -62,8 +62,8 @@
         }
     },
     "source": {
-        "approval": "#pragma version 10

tests.artifacts.StateOps.contract.StateAssetParamsContract.approval_program:
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@16
    method "verify_asset_params_get_total(asset)uint64"
    method "verify_asset_params_get_decimals(asset)uint64"
    method "verify_asset_params_get_default_frozen(asset)bool"
    method "verify_asset_params_get_unit_name(asset)byte[]"
    method "verify_asset_params_get_name(asset)byte[]"
    method "verify_asset_params_get_url(asset)byte[]"
    method "verify_asset_params_get_metadata_hash(asset)byte[]"
    method "verify_asset_params_get_manager(asset)address"
    method "verify_asset_params_get_reserve(asset)address"
    method "verify_asset_params_get_freeze(asset)address"
    method "verify_asset_params_get_clawback(asset)address"
    method "verify_asset_params_get_creator(asset)address"
    txna ApplicationArgs 0
    match main_verify_asset_params_get_total_route@2 main_verify_asset_params_get_decimals_route@3 main_verify_asset_params_get_default_frozen_route@4 main_verify_asset_params_get_unit_name_route@5 main_verify_asset_params_get_name_route@6 main_verify_asset_params_get_url_route@7 main_verify_asset_params_get_metadata_hash_route@8 main_verify_asset_params_get_manager_route@9 main_verify_asset_params_get_reserve_route@10 main_verify_asset_params_get_freeze_route@11 main_verify_asset_params_get_clawback_route@12 main_verify_asset_params_get_creator_route@13
    err // reject transaction

main_verify_asset_params_get_total_route@2:
    // tests/artifacts/StateOps/contract.py:151
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:151
    // @arc4.abimethod()
    callsub verify_asset_params_get_total
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_decimals_route@3:
    // tests/artifacts/StateOps/contract.py:159
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:159
    // @arc4.abimethod()
    callsub verify_asset_params_get_decimals
    itob
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_default_frozen_route@4:
    // tests/artifacts/StateOps/contract.py:167
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:167
    // @arc4.abimethod()
    callsub verify_asset_params_get_default_frozen
    byte 0x00
    int 0
    uncover 2
    setbit
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_unit_name_route@5:
    // tests/artifacts/StateOps/contract.py:175
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:175
    // @arc4.abimethod()
    callsub verify_asset_params_get_unit_name
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_name_route@6:
    // tests/artifacts/StateOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:183
    // @arc4.abimethod()
    callsub verify_asset_params_get_name
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_url_route@7:
    // tests/artifacts/StateOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:191
    // @arc4.abimethod()
    callsub verify_asset_params_get_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_metadata_hash_route@8:
    // tests/artifacts/StateOps/contract.py:199
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:199
    // @arc4.abimethod()
    callsub verify_asset_params_get_metadata_hash
    dup
    len
    itob
    extract 6 2
    swap
    concat
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_manager_route@9:
    // tests/artifacts/StateOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:207
    // @arc4.abimethod()
    callsub verify_asset_params_get_manager
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_reserve_route@10:
    // tests/artifacts/StateOps/contract.py:215
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:215
    // @arc4.abimethod()
    callsub verify_asset_params_get_reserve
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_freeze_route@11:
    // tests/artifacts/StateOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:223
    // @arc4.abimethod()
    callsub verify_asset_params_get_freeze
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_clawback_route@12:
    // tests/artifacts/StateOps/contract.py:231
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:231
    // @arc4.abimethod()
    callsub verify_asset_params_get_clawback
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_verify_asset_params_get_creator_route@13:
    // tests/artifacts/StateOps/contract.py:239
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:239
    // @arc4.abimethod()
    callsub verify_asset_params_get_creator
    byte 0x151f7c75
    swap
    concat
    log
    int 1
    return

main_bare_routing@16:
    // tests/artifacts/StateOps/contract.py:150
    // class StateAssetParamsContract(ARC4Contract):
    txn OnCompletion
    !
    assert // reject transaction
    txn ApplicationID
    !
    assert // is creating
    int 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_total(a: uint64) -> uint64:
verify_asset_params_get_total:
    // tests/artifacts/StateOps/contract.py:151-152
    // @arc4.abimethod()
    // def verify_asset_params_get_total(self, a: Asset) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:153
    // value, exists = op.AssetParamsGet.asset_total(a)
    frame_dig -1
    asset_params_get AssetTotal
    swap
    // tests/artifacts/StateOps/contract.py:154
    // value_index, exists_index = op.AssetParamsGet.asset_total(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetTotal
    cover 2
    // tests/artifacts/StateOps/contract.py:155
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:156
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:157
    // return value
    retsub


// tests.artifacts.StateOps.contract._get_1st_ref_index() -> uint64:
_get_1st_ref_index:
    // tests/artifacts/StateOps/contract.py:19-20
    // @subroutine
    // def _get_1st_ref_index() -> UInt64:
    proto 0 1
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_decimals(a: uint64) -> uint64:
verify_asset_params_get_decimals:
    // tests/artifacts/StateOps/contract.py:159-160
    // @arc4.abimethod()
    // def verify_asset_params_get_decimals(self, a: Asset) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:161
    // value, exists = op.AssetParamsGet.asset_decimals(a)
    frame_dig -1
    asset_params_get AssetDecimals
    swap
    // tests/artifacts/StateOps/contract.py:162
    // value_index, exists_index = op.AssetParamsGet.asset_decimals(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetDecimals
    cover 2
    // tests/artifacts/StateOps/contract.py:163
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:164
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:165
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_default_frozen(a: uint64) -> uint64:
verify_asset_params_get_default_frozen:
    // tests/artifacts/StateOps/contract.py:167-168
    // @arc4.abimethod()
    // def verify_asset_params_get_default_frozen(self, a: Asset) -> bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:169
    // value, exists = op.AssetParamsGet.asset_default_frozen(a)
    frame_dig -1
    asset_params_get AssetDefaultFrozen
    swap
    // tests/artifacts/StateOps/contract.py:170
    // value_index, exists_index = op.AssetParamsGet.asset_default_frozen(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetDefaultFrozen
    cover 2
    // tests/artifacts/StateOps/contract.py:171
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:172
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:173
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_unit_name(a: uint64) -> bytes:
verify_asset_params_get_unit_name:
    // tests/artifacts/StateOps/contract.py:175-176
    // @arc4.abimethod()
    // def verify_asset_params_get_unit_name(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:177
    // value, exists = op.AssetParamsGet.asset_unit_name(a)
    frame_dig -1
    asset_params_get AssetUnitName
    swap
    // tests/artifacts/StateOps/contract.py:178
    // value_index, exists_index = op.AssetParamsGet.asset_unit_name(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetUnitName
    cover 2
    // tests/artifacts/StateOps/contract.py:179
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:180
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:181
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_name(a: uint64) -> bytes:
verify_asset_params_get_name:
    // tests/artifacts/StateOps/contract.py:183-184
    // @arc4.abimethod()
    // def verify_asset_params_get_name(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:185
    // value, exists = op.AssetParamsGet.asset_name(a)
    frame_dig -1
    asset_params_get AssetName
    swap
    // tests/artifacts/StateOps/contract.py:186
    // value_index, exists_index = op.AssetParamsGet.asset_name(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetName
    cover 2
    // tests/artifacts/StateOps/contract.py:187
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:188
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:189
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_url(a: uint64) -> bytes:
verify_asset_params_get_url:
    // tests/artifacts/StateOps/contract.py:191-192
    // @arc4.abimethod()
    // def verify_asset_params_get_url(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:193
    // value, exists = op.AssetParamsGet.asset_url(a)
    frame_dig -1
    asset_params_get AssetURL
    swap
    // tests/artifacts/StateOps/contract.py:194
    // value_index, exists_index = op.AssetParamsGet.asset_url(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetURL
    cover 2
    // tests/artifacts/StateOps/contract.py:195
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:196
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:197
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_metadata_hash(a: uint64) -> bytes:
verify_asset_params_get_metadata_hash:
    // tests/artifacts/StateOps/contract.py:199-200
    // @arc4.abimethod()
    // def verify_asset_params_get_metadata_hash(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:201
    // value, exists = op.AssetParamsGet.asset_metadata_hash(a)
    frame_dig -1
    asset_params_get AssetMetadataHash
    swap
    // tests/artifacts/StateOps/contract.py:202
    // value_index, exists_index = op.AssetParamsGet.asset_metadata_hash(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetMetadataHash
    cover 2
    // tests/artifacts/StateOps/contract.py:203
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:204
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:205
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_manager(a: uint64) -> bytes:
verify_asset_params_get_manager:
    // tests/artifacts/StateOps/contract.py:207-208
    // @arc4.abimethod()
    // def verify_asset_params_get_manager(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:209
    // value, exists = op.AssetParamsGet.asset_manager(a)
    frame_dig -1
    asset_params_get AssetManager
    swap
    // tests/artifacts/StateOps/contract.py:210
    // value_index, exists_index = op.AssetParamsGet.asset_manager(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetManager
    cover 2
    // tests/artifacts/StateOps/contract.py:211
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:212
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:213
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_reserve(a: uint64) -> bytes:
verify_asset_params_get_reserve:
    // tests/artifacts/StateOps/contract.py:215-216
    // @arc4.abimethod()
    // def verify_asset_params_get_reserve(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:217
    // value, exists = op.AssetParamsGet.asset_reserve(a)
    frame_dig -1
    asset_params_get AssetReserve
    swap
    // tests/artifacts/StateOps/contract.py:218
    // value_index, exists_index = op.AssetParamsGet.asset_reserve(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetReserve
    cover 2
    // tests/artifacts/StateOps/contract.py:219
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:220
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:221
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_freeze(a: uint64) -> bytes:
verify_asset_params_get_freeze:
    // tests/artifacts/StateOps/contract.py:223-224
    // @arc4.abimethod()
    // def verify_asset_params_get_freeze(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:225
    // value, exists = op.AssetParamsGet.asset_freeze(a)
    frame_dig -1
    asset_params_get AssetFreeze
    swap
    // tests/artifacts/StateOps/contract.py:226
    // value_index, exists_index = op.AssetParamsGet.asset_freeze(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetFreeze
    cover 2
    // tests/artifacts/StateOps/contract.py:227
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:228
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:229
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_clawback(a: uint64) -> bytes:
verify_asset_params_get_clawback:
    // tests/artifacts/StateOps/contract.py:231-232
    // @arc4.abimethod()
    // def verify_asset_params_get_clawback(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:233
    // value, exists = op.AssetParamsGet.asset_clawback(a)
    frame_dig -1
    asset_params_get AssetClawback
    swap
    // tests/artifacts/StateOps/contract.py:234
    // value_index, exists_index = op.AssetParamsGet.asset_clawback(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetClawback
    cover 2
    // tests/artifacts/StateOps/contract.py:235
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:236
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:237
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_creator(a: uint64) -> bytes:
verify_asset_params_get_creator:
    // tests/artifacts/StateOps/contract.py:239-240
    // @arc4.abimethod()
    // def verify_asset_params_get_creator(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:241
    // value, exists = op.AssetParamsGet.asset_creator(a)
    frame_dig -1
    asset_params_get AssetCreator
    swap
    // tests/artifacts/StateOps/contract.py:242
    // value_index, exists_index = op.AssetParamsGet.asset_creator(_get_1st_ref_index())
    callsub _get_1st_ref_index
    asset_params_get AssetCreator
    cover 2
    // tests/artifacts/StateOps/contract.py:243
    // assert value == value_index, "expected value by index to match"
    dig 1
    ==
    assert // expected value by index to match
    // tests/artifacts/StateOps/contract.py:244
    // assert exists == exists_index, "expected exists by index to match"
    cover 2
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:245
    // return arc4.Address(value)
    retsub
",
-        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy5hcnRpZmFjdHMuU3RhdGVPcHMuY29udHJhY3QuU3RhdGVBc3NldFBhcmFtc0NvbnRyYWN0LmNsZWFyX3N0YXRlX3Byb2dyYW06CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvU3RhdGVPcHMvY29udHJhY3QucHk6MTUwCiAgICAvLyBjbGFzcyBTdGF0ZUFzc2V0UGFyYW1zQ29udHJhY3QoQVJDNENvbnRyYWN0KToKICAgIGludCAxCiAgICByZXR1cm4K"
+        "approval": "#pragma version 10
#pragma typetrack false

// algopy.arc4.ARC4Contract.approval_program() -> uint64:
main:
    intcblock 1 0
    bytecblock 0x151f7c75
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txn NumAppArgs
    bz main_bare_routing@17
    pushbytess 0xad719a6f 0x1d603013 0x9fb731cd 0x0f5a4911 0xf5b370c6 0xc7d6af74 0x6b71a263 0x3040ebc8 0x1d07e844 0x3e40cb50 0x340c786b 0xe38a9815 // method "verify_asset_params_get_total(asset)uint64", method "verify_asset_params_get_decimals(asset)uint64", method "verify_asset_params_get_default_frozen(asset)bool", method "verify_asset_params_get_unit_name(asset)byte[]", method "verify_asset_params_get_name(asset)byte[]", method "verify_asset_params_get_url(asset)byte[]", method "verify_asset_params_get_metadata_hash(asset)byte[]", method "verify_asset_params_get_manager(asset)address", method "verify_asset_params_get_reserve(asset)address", method "verify_asset_params_get_freeze(asset)address", method "verify_asset_params_get_clawback(asset)address", method "verify_asset_params_get_creator(asset)address"
    txna ApplicationArgs 0
    match main_verify_asset_params_get_total_route@3 main_verify_asset_params_get_decimals_route@4 main_verify_asset_params_get_default_frozen_route@5 main_verify_asset_params_get_unit_name_route@6 main_verify_asset_params_get_name_route@7 main_verify_asset_params_get_url_route@8 main_verify_asset_params_get_metadata_hash_route@9 main_verify_asset_params_get_manager_route@10 main_verify_asset_params_get_reserve_route@11 main_verify_asset_params_get_freeze_route@12 main_verify_asset_params_get_clawback_route@13 main_verify_asset_params_get_creator_route@14

main_after_if_else@21:
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    intc_1 // 0
    return

main_verify_asset_params_get_creator_route@14:
    // tests/artifacts/StateOps/contract.py:263
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:263
    // @arc4.abimethod()
    callsub verify_asset_params_get_creator
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_clawback_route@13:
    // tests/artifacts/StateOps/contract.py:255
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:255
    // @arc4.abimethod()
    callsub verify_asset_params_get_clawback
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_freeze_route@12:
    // tests/artifacts/StateOps/contract.py:247
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:247
    // @arc4.abimethod()
    callsub verify_asset_params_get_freeze
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_reserve_route@11:
    // tests/artifacts/StateOps/contract.py:239
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:239
    // @arc4.abimethod()
    callsub verify_asset_params_get_reserve
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_manager_route@10:
    // tests/artifacts/StateOps/contract.py:231
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:231
    // @arc4.abimethod()
    callsub verify_asset_params_get_manager
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_metadata_hash_route@9:
    // tests/artifacts/StateOps/contract.py:223
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:223
    // @arc4.abimethod()
    callsub verify_asset_params_get_metadata_hash
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_url_route@8:
    // tests/artifacts/StateOps/contract.py:215
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:215
    // @arc4.abimethod()
    callsub verify_asset_params_get_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_name_route@7:
    // tests/artifacts/StateOps/contract.py:207
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:207
    // @arc4.abimethod()
    callsub verify_asset_params_get_name
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_unit_name_route@6:
    // tests/artifacts/StateOps/contract.py:199
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:199
    // @arc4.abimethod()
    callsub verify_asset_params_get_unit_name
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_default_frozen_route@5:
    // tests/artifacts/StateOps/contract.py:191
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:191
    // @arc4.abimethod()
    callsub verify_asset_params_get_default_frozen
    pushbytes 0x00
    intc_1 // 0
    uncover 2
    setbit
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_decimals_route@4:
    // tests/artifacts/StateOps/contract.py:183
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:183
    // @arc4.abimethod()
    callsub verify_asset_params_get_decimals
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_verify_asset_params_get_total_route@3:
    // tests/artifacts/StateOps/contract.py:175
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txna ApplicationArgs 1
    btoi
    txnas Assets
    // tests/artifacts/StateOps/contract.py:175
    // @arc4.abimethod()
    callsub verify_asset_params_get_total
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    return

main_bare_routing@17:
    // tests/artifacts/StateOps/contract.py:174
    // class StateAssetParamsContract(ARC4Contract):
    txn OnCompletion
    bnz main_after_if_else@21
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    return


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_total(a: uint64) -> uint64:
verify_asset_params_get_total:
    // tests/artifacts/StateOps/contract.py:175-176
    // @arc4.abimethod()
    // def verify_asset_params_get_total(self, a: Asset) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:177
    // value, exists = op.AssetParamsGet.asset_total(a)
    frame_dig -1
    asset_params_get AssetTotal
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:178
    // value_index, exists_index = op.AssetParamsGet.asset_total(_get_1st_ref_index())
    asset_params_get AssetTotal
    // tests/artifacts/StateOps/contract.py:179
    // 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:180
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:181
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_decimals(a: uint64) -> uint64:
verify_asset_params_get_decimals:
    // tests/artifacts/StateOps/contract.py:183-184
    // @arc4.abimethod()
    // def verify_asset_params_get_decimals(self, a: Asset) -> UInt64:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:185
    // value, exists = op.AssetParamsGet.asset_decimals(a)
    frame_dig -1
    asset_params_get AssetDecimals
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:186
    // value_index, exists_index = op.AssetParamsGet.asset_decimals(_get_1st_ref_index())
    asset_params_get AssetDecimals
    // tests/artifacts/StateOps/contract.py:187
    // 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:188
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:189
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_default_frozen(a: uint64) -> uint64:
verify_asset_params_get_default_frozen:
    // tests/artifacts/StateOps/contract.py:191-192
    // @arc4.abimethod()
    // def verify_asset_params_get_default_frozen(self, a: Asset) -> bool:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:193
    // value, exists = op.AssetParamsGet.asset_default_frozen(a)
    frame_dig -1
    asset_params_get AssetDefaultFrozen
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:194
    // value_index, exists_index = op.AssetParamsGet.asset_default_frozen(_get_1st_ref_index())
    asset_params_get AssetDefaultFrozen
    // tests/artifacts/StateOps/contract.py:195
    // 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:196
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:197
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_unit_name(a: uint64) -> bytes:
verify_asset_params_get_unit_name:
    // tests/artifacts/StateOps/contract.py:199-200
    // @arc4.abimethod()
    // def verify_asset_params_get_unit_name(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:201
    // value, exists = op.AssetParamsGet.asset_unit_name(a)
    frame_dig -1
    asset_params_get AssetUnitName
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:202
    // value_index, exists_index = op.AssetParamsGet.asset_unit_name(_get_1st_ref_index())
    asset_params_get AssetUnitName
    // tests/artifacts/StateOps/contract.py:203
    // 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:204
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:205
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_name(a: uint64) -> bytes:
verify_asset_params_get_name:
    // tests/artifacts/StateOps/contract.py:207-208
    // @arc4.abimethod()
    // def verify_asset_params_get_name(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:209
    // value, exists = op.AssetParamsGet.asset_name(a)
    frame_dig -1
    asset_params_get AssetName
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:210
    // value_index, exists_index = op.AssetParamsGet.asset_name(_get_1st_ref_index())
    asset_params_get AssetName
    // tests/artifacts/StateOps/contract.py:211
    // 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:212
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:213
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_url(a: uint64) -> bytes:
verify_asset_params_get_url:
    // tests/artifacts/StateOps/contract.py:215-216
    // @arc4.abimethod()
    // def verify_asset_params_get_url(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:217
    // value, exists = op.AssetParamsGet.asset_url(a)
    frame_dig -1
    asset_params_get AssetURL
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:218
    // value_index, exists_index = op.AssetParamsGet.asset_url(_get_1st_ref_index())
    asset_params_get AssetURL
    // tests/artifacts/StateOps/contract.py:219
    // 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:220
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:221
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_metadata_hash(a: uint64) -> bytes:
verify_asset_params_get_metadata_hash:
    // tests/artifacts/StateOps/contract.py:223-224
    // @arc4.abimethod()
    // def verify_asset_params_get_metadata_hash(self, a: Asset) -> Bytes:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:225
    // value, exists = op.AssetParamsGet.asset_metadata_hash(a)
    frame_dig -1
    asset_params_get AssetMetadataHash
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:226
    // value_index, exists_index = op.AssetParamsGet.asset_metadata_hash(_get_1st_ref_index())
    asset_params_get AssetMetadataHash
    // tests/artifacts/StateOps/contract.py:227
    // 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:228
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:229
    // return value
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_manager(a: uint64) -> bytes:
verify_asset_params_get_manager:
    // tests/artifacts/StateOps/contract.py:231-232
    // @arc4.abimethod()
    // def verify_asset_params_get_manager(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:233
    // value, exists = op.AssetParamsGet.asset_manager(a)
    frame_dig -1
    asset_params_get AssetManager
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:234
    // value_index, exists_index = op.AssetParamsGet.asset_manager(_get_1st_ref_index())
    asset_params_get AssetManager
    // tests/artifacts/StateOps/contract.py:235
    // 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:236
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:237
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_reserve(a: uint64) -> bytes:
verify_asset_params_get_reserve:
    // tests/artifacts/StateOps/contract.py:239-240
    // @arc4.abimethod()
    // def verify_asset_params_get_reserve(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:241
    // value, exists = op.AssetParamsGet.asset_reserve(a)
    frame_dig -1
    asset_params_get AssetReserve
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:242
    // value_index, exists_index = op.AssetParamsGet.asset_reserve(_get_1st_ref_index())
    asset_params_get AssetReserve
    // tests/artifacts/StateOps/contract.py:243
    // 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:244
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:245
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_freeze(a: uint64) -> bytes:
verify_asset_params_get_freeze:
    // tests/artifacts/StateOps/contract.py:247-248
    // @arc4.abimethod()
    // def verify_asset_params_get_freeze(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:249
    // value, exists = op.AssetParamsGet.asset_freeze(a)
    frame_dig -1
    asset_params_get AssetFreeze
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:250
    // value_index, exists_index = op.AssetParamsGet.asset_freeze(_get_1st_ref_index())
    asset_params_get AssetFreeze
    // tests/artifacts/StateOps/contract.py:251
    // 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:252
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:253
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_clawback(a: uint64) -> bytes:
verify_asset_params_get_clawback:
    // tests/artifacts/StateOps/contract.py:255-256
    // @arc4.abimethod()
    // def verify_asset_params_get_clawback(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:257
    // value, exists = op.AssetParamsGet.asset_clawback(a)
    frame_dig -1
    asset_params_get AssetClawback
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:258
    // value_index, exists_index = op.AssetParamsGet.asset_clawback(_get_1st_ref_index())
    asset_params_get AssetClawback
    // tests/artifacts/StateOps/contract.py:259
    // 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:260
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:261
    // return arc4.Address(value)
    retsub


// tests.artifacts.StateOps.contract.StateAssetParamsContract.verify_asset_params_get_creator(a: uint64) -> bytes:
verify_asset_params_get_creator:
    // tests/artifacts/StateOps/contract.py:263-264
    // @arc4.abimethod()
    // def verify_asset_params_get_creator(self, a: Asset) -> arc4.Address:
    proto 1 1
    // tests/artifacts/StateOps/contract.py:265
    // value, exists = op.AssetParamsGet.asset_creator(a)
    frame_dig -1
    asset_params_get AssetCreator
    // tests/artifacts/StateOps/contract.py:21
    // return op.btoi(Txn.application_args(1))
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/StateOps/contract.py:266
    // value_index, exists_index = op.AssetParamsGet.asset_creator(_get_1st_ref_index())
    asset_params_get AssetCreator
    // tests/artifacts/StateOps/contract.py:267
    // 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:268
    // assert exists == exists_index, "expected exists by index to match"
    ==
    assert // expected exists by index to match
    // tests/artifacts/StateOps/contract.py:269
    // return arc4.Address(value)
    retsub
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
     },
     "state": {
         "global": {
diff --git a/tests/artifacts/StateOps/data/StateAssetParamsContract.clear.teal b/tests/artifacts/StateOps/data/StateAssetParamsContract.clear.teal
index 21cbde0..a433105 100644
--- a/tests/artifacts/StateOps/data/StateAssetParamsContract.clear.teal
+++ b/tests/artifacts/StateOps/data/StateAssetParamsContract.clear.teal
@@ -1,7 +1,7 @@
 #pragma version 10
+#pragma typetrack false
 
-tests.artifacts.StateOps.contract.StateAssetParamsContract.clear_state_program:
-    // tests/artifacts/StateOps/contract.py:150
-    // class StateAssetParamsContract(ARC4Contract):
-    int 1
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
     return

From 995b517336d682c316c3435cf196d621f3c0a9f7 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 17:30:22 +0800
Subject: [PATCH 16/23] chore: ignore puya map files from artifacts

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index a5ffbcd..29ae6ef 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,3 +17,4 @@ coverage.xml
 .venv*
 
 .cursorignore
+*.puya.map

From 45a04de69720987acce392020a9d0c78b1791bc5 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 18:07:18 +0800
Subject: [PATCH 17/23] feat: update `algopy.op.Block` with fields added in AVM
 11

---
 .../context_helpers/ledger_context.py         | 44 +++++++++++++++---
 src/_algopy_testing/op/block.py               | 45 ++++++++++++++-----
 tests/test_op.py                              | 33 +++++++++++++-
 3 files changed, 103 insertions(+), 19 deletions(-)

diff --git a/src/_algopy_testing/context_helpers/ledger_context.py b/src/_algopy_testing/context_helpers/ledger_context.py
index 0bac6d0..903c264 100644
--- a/src/_algopy_testing/context_helpers/ledger_context.py
+++ b/src/_algopy_testing/context_helpers/ledger_context.py
@@ -3,6 +3,8 @@
 import typing
 from collections import defaultdict
 
+import algosdk.constants
+
 from _algopy_testing.constants import MAX_BOX_SIZE
 from _algopy_testing.models.account import Account
 from _algopy_testing.primitives.uint64 import UInt64
@@ -31,7 +33,7 @@ def __init__(self) -> None:
         self._account_data = defaultdict[str, AccountContextData](get_empty_account)
         self._app_data: dict[int, ApplicationContextData] = {}
         self._asset_data: dict[int, AssetFields] = {}
-        self._blocks: dict[int, dict[str, int]] = {}
+        self._blocks: dict[int, dict[str, int | bytes | str]] = {}
         self._global_fields: GlobalFields = get_default_global_fields()
 
         self._asset_id = iter(range(1001, 2**64))
@@ -365,8 +367,19 @@ def box_exists(
         boxes = self._get_app_data(app).boxes
         return _as_box_key(key) in boxes
 
-    def set_block(
-        self, index: int, seed: algopy.UInt64 | int, timestamp: algopy.UInt64 | int
+    def set_block(  # noqa: PLR0913
+        self,
+        index: int,
+        seed: algopy.UInt64 | int,
+        timestamp: algopy.UInt64 | int,
+        bonus: algopy.UInt64 | int = 0,
+        branch: algopy.Bytes | bytes = b"",
+        fee_sink: algopy.Account | str = algosdk.constants.ZERO_ADDRESS,
+        fees_collected: algopy.UInt64 | int = 0,
+        proposer: algopy.Account | str = algosdk.constants.ZERO_ADDRESS,
+        proposer_payout: algopy.UInt64 | int = 0,
+        protocol: algopy.Bytes | bytes = b"",
+        txn_counter: algopy.UInt64 | int = 0,
     ) -> None:
         """Set block content.
 
@@ -374,10 +387,29 @@ def set_block(
             index (int): The block index.
             seed (algopy.UInt64 | int): The block seed.
             timestamp (algopy.UInt64 | int): The block timestamp.
+            bonus (algopy.UInt64 | int): The block bonus.
+            branch (algopy.Bytes | bytes): The block branch.
+            fee_sink (algopy.Account | str): The block fee sink.
+            fees_collected (algopy.UInt64 | int): The fess collected.
+            proposer (algopy.Account | str): The block proposer.
+            proposer_payout (algopy.UInt64 | int): The block proposer payout.
+            protocol (algopy.Bytes | bytes): The block protocol.
+            txn_counter (algopy.UInt64 | int): The block transaction counter.
         """
-        self._blocks[index] = {"seed": int(seed), "timestamp": int(timestamp)}
-
-    def get_block_content(self, index: int, key: str) -> int:
+        self._blocks[index] = {
+            "seed": int(seed),
+            "timestamp": int(timestamp),
+            "bonus": int(bonus),
+            "branch": as_bytes(branch),
+            "fee_sink": str(fee_sink),
+            "fees_collected": int(fees_collected),
+            "proposer": str(proposer),
+            "proposer_payout": int(proposer_payout),
+            "protocol": as_bytes(protocol),
+            "txn_counter": int(txn_counter),
+        }
+
+    def get_block_content(self, index: int, key: str) -> int | bytes | str:
         """Get block content.
 
         Args:
diff --git a/src/_algopy_testing/op/block.py b/src/_algopy_testing/op/block.py
index ec85df4..3ee9e28 100644
--- a/src/_algopy_testing/op/block.py
+++ b/src/_algopy_testing/op/block.py
@@ -1,28 +1,51 @@
 from __future__ import annotations
 
+import typing
 from typing import TYPE_CHECKING
 
 from _algopy_testing import op
 from _algopy_testing.context_helpers import lazy_context
-from _algopy_testing.primitives import UInt64
+from _algopy_testing.models.account import Account
+from _algopy_testing.primitives import Bytes, UInt64
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     import algopy
 
 
-class Block:
-    @staticmethod
-    def blk_seed(a: algopy.UInt64 | int, /) -> algopy.Bytes:
+_T = typing.TypeVar("_T")
+
+
+def _make_block_method(
+    field: str, conv: Callable[[typing.Any], _T]
+) -> Callable[[algopy.UInt64 | int], _T]:
+    def _read_block(index: algopy.UInt64 | int) -> _T:
         try:
-            index = int(a)
-            return op.itob(lazy_context.ledger.get_block_content(index, "seed"))
+            return conv(lazy_context.ledger.get_block_content(int(index), field))
         except KeyError as e:
-            raise KeyError(f"Block {a} not set") from e
+            raise KeyError(f"Block {index} not set") from e
 
+    return _read_block
+
+
+class Block:
     @staticmethod
-    def blk_timestamp(a: algopy.UInt64 | int, /) -> algopy.UInt64:
+    def blk_seed(index: algopy.UInt64 | int) -> Bytes:
         try:
-            index = int(a)
-            return UInt64(lazy_context.ledger.get_block_content(index, "timestamp"))
+            value = lazy_context.ledger.get_block_content(int(index), "seed")
         except KeyError as e:
-            raise KeyError(f"Block {a} not set") from e
+            raise KeyError(f"Block {index} not set") from e
+        else:
+            assert isinstance(value, int), "expected int for blk_seed"
+            return op.itob(value)
+
+    blk_timestamp = _make_block_method("timestamp", UInt64)
+    blk_bonus = _make_block_method("bonus", UInt64)
+    blk_proposer = _make_block_method("proposer", Account)
+    blk_fees_collected = _make_block_method("fees_collected", UInt64)
+    blk_txn_counter = _make_block_method("txn_counter", UInt64)
+    blk_proposer_payout = _make_block_method("proposer_payout", UInt64)
+    blk_branch = _make_block_method("branch", Bytes)
+    blk_protocol = _make_block_method("protocol", Bytes)
+    blk_fee_sink = _make_block_method("fee_sink", Account)
diff --git a/tests/test_op.py b/tests/test_op.py
index f4309c0..648e86d 100644
--- a/tests/test_op.py
+++ b/tests/test_op.py
@@ -938,13 +938,42 @@ def test_itxn_ops(context: AlgopyTestContext) -> None:
     assert hasattr(appl_itxn, "created_app")
 
 
-def test_blk_seed_existing_block(context: AlgopyTestContext) -> None:
+def test_blk_existing_block(context: AlgopyTestContext) -> None:
     block_index = 42
     block_seed = 123
-    context.ledger.set_block(block_index, block_seed, 1234567890)
+    sink = context.any.account()
+    fees = context.any.uint64()
+    bonus = context.any.uint64()
+    proposer = context.any.account()
+    payout = context.any.uint64()
+    protocol = context.any.bytes()
+    branch = context.any.bytes()
+    counter = context.any.uint64()
+    context.ledger.set_block(
+        block_index,
+        seed=block_seed,
+        timestamp=1234567890,
+        fee_sink=sink,
+        fees_collected=fees,
+        proposer=proposer,
+        proposer_payout=payout,
+        protocol=protocol,
+        txn_counter=counter,
+        bonus=bonus,
+        branch=branch,
+    )
     result = op.Block.blk_seed(algopy.UInt64(block_index))
     assert op.btoi(result) == block_seed
 
+    assert op.Block.blk_fee_sink(block_index) == sink
+    assert op.Block.blk_fees_collected(block_index) == fees
+    assert op.Block.blk_proposer(block_index) == proposer
+    assert op.Block.blk_proposer_payout(block_index) == payout
+    assert op.Block.blk_protocol(block_index) == protocol
+    assert op.Block.blk_txn_counter(block_index) == counter
+    assert op.Block.blk_bonus(block_index) == bonus
+    assert op.Block.blk_branch(block_index) == branch
+
 
 @pytest.mark.usefixtures("context")
 def test_blk_seed_missing_block() -> None:

From ac406797675b32b5a7819b07101884879d2dc3b7 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 18:37:00 +0800
Subject: [PATCH 18/23] feat: support mocking new `algopy.op` functions
 `falcon_verify`, `mimc`, `online_stake`, `sumhash512` and `VoterParamsGet`

---
 src/_algopy_testing/op/__init__.py | 12 ++++++++++++
 src/_algopy_testing/op/crypto.py   | 17 +++++++++++++++++
 src/_algopy_testing/op/misc.py     | 14 ++++++++++++++
 3 files changed, 43 insertions(+)

diff --git a/src/_algopy_testing/op/__init__.py b/src/_algopy_testing/op/__init__.py
index e8ad9f7..ef09369 100644
--- a/src/_algopy_testing/op/__init__.py
+++ b/src/_algopy_testing/op/__init__.py
@@ -3,16 +3,20 @@
     EC,
     ECDSA,
     EllipticCurve,
+    MiMCConfigurations,
     VrfVerify,
     ecdsa_pk_decompress,
     ecdsa_pk_recover,
     ecdsa_verify,
     ed25519verify,
     ed25519verify_bare,
+    falcon_verify,
     keccak256,
+    mimc,
     sha3_256,
     sha256,
     sha512_256,
+    sumhash512,
     vrf_verify,
 )
 from _algopy_testing.op.global_values import Global
@@ -26,6 +30,7 @@
     AssetParamsGet,
     Box,
     Scratch,
+    VoterParamsGet,
     app_opted_in,
     arg,
     balance,
@@ -35,6 +40,7 @@
     gload_bytes,
     gload_uint64,
     min_balance,
+    online_stake,
 )
 from _algopy_testing.op.pure import (
     Base64,
@@ -90,8 +96,10 @@
     "ITxn",
     "ITxnCreate",
     "JsonRef",
+    "MiMCConfigurations",
     "Scratch",
     "Txn",
+    "VoterParamsGet",
     "VrfVerify",
     "addw",
     "arg",
@@ -118,6 +126,7 @@
     "extract_uint16",
     "extract_uint32",
     "extract_uint64",
+    "falcon_verify",
     "gaid",
     "getbit",
     "getbyte",
@@ -126,7 +135,9 @@
     "itob",
     "keccak256",
     "min_balance",
+    "mimc",
     "mulw",
+    "online_stake",
     "replace",
     "select_bytes",
     "select_uint64",
@@ -140,5 +151,6 @@
     "shr",
     "sqrt",
     "substring",
+    "sumhash512",
     "vrf_verify",
 ]
diff --git a/src/_algopy_testing/op/crypto.py b/src/_algopy_testing/op/crypto.py
index fc3dbb6..48062d5 100644
--- a/src/_algopy_testing/op/crypto.py
+++ b/src/_algopy_testing/op/crypto.py
@@ -42,6 +42,10 @@ def sha3_256(a: Bytes | bytes, /) -> Bytes:
     return Bytes(hashlib.sha3_256(input_value).digest())
 
 
+def sumhash512(_a: Bytes | bytes, /) -> Bytes:
+    raise_mocked_function_error("sumhash512")
+
+
 def keccak256(a: Bytes | bytes, /) -> Bytes:
     input_value = as_bytes(a)
     hashed_value = keccak.new(data=input_value, digest_bits=256)
@@ -167,6 +171,10 @@ def ecdsa_pk_decompress(v: ECDSA, a: Bytes | bytes, /) -> tuple[Bytes, Bytes]:
         )
 
 
+def falcon_verify(_a: Bytes | bytes, _b: Bytes | bytes, _c: Bytes | bytes, /) -> bool:
+    raise_mocked_function_error("falcon_verify")
+
+
 def vrf_verify(
     _s: VrfVerify,
     _a: Bytes | bytes,
@@ -202,3 +210,12 @@ class EllipticCurve:
     scalar_mul = _MockedMember()
     scalar_mul_multi = _MockedMember()
     subgroup_check = _MockedMember()
+
+
+class MiMCConfigurations(enum.StrEnum):
+    BN254Mp110 = enum.auto()
+    BLS12_381Mp111 = enum.auto()
+
+
+def mimc(_c: MiMCConfigurations, _a: Bytes | bytes, /) -> Bytes:
+    raise_mocked_function_error("mimc")
diff --git a/src/_algopy_testing/op/misc.py b/src/_algopy_testing/op/misc.py
index 15178b6..eda2664 100644
--- a/src/_algopy_testing/op/misc.py
+++ b/src/_algopy_testing/op/misc.py
@@ -638,3 +638,17 @@ def splice(
 
         # Update the box with the new content
         lazy_context.ledger.set_box(app_id, key, new_content)
+
+
+def online_stake() -> UInt64:
+    raise_mocked_function_error("online_stake")
+
+
+class VoterParamsGet:
+    @staticmethod
+    def voter_balance(_a: Account | UInt64 | int, /) -> tuple[UInt64, bool]:
+        raise_mocked_function_error("VoterParamsGet.voter_balance")
+
+    @staticmethod
+    def voter_incentive_eligible(_a: Account | UInt64 | int, /) -> tuple[bool, bool]:
+        raise_mocked_function_error("VoterParamsGet.voter_balance")

From d90d4bec0f4648ab15cdb53cc85e010f57345978 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Mon, 17 Feb 2025 09:56:19 +0800
Subject: [PATCH 19/23] chore: ensure refresh_test_artifacts captures all
 contracts

---
 scripts/refresh_test_artifacts.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/refresh_test_artifacts.py b/scripts/refresh_test_artifacts.py
index 359f50a..0b00a4d 100644
--- a/scripts/refresh_test_artifacts.py
+++ b/scripts/refresh_test_artifacts.py
@@ -16,13 +16,13 @@
 
 def get_artifact_folders(root_dir: str) -> Iterator[Path]:
     for folder in Path(root_dir).iterdir():
-        if folder.is_dir() and (folder / "contract.py").exists():
+        if folder.is_dir() and not str(folder.stem).startswith((".", "__")):
             yield folder
 
 
 def compile_contract(folder: Path) -> None:
     logger.info(f"Compiling: {folder}")
-    contract_path = folder / "contract.py"
+    contract_path = folder
     (folder / "data").mkdir(exist_ok=True)
     compile_cmd = [
         "hatch",

From 1e939c38a666c9cb8d8d9a3bdd5c72c1a3ae72f4 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Mon, 17 Feb 2025 09:56:30 +0800
Subject: [PATCH 20/23] chore: refresh test artifacts

---
 .../data/AppCall.approval.teal                |  58 ++
 .../CreatedAppAsset/data/AppCall.arc32.json   |  50 ++
 .../CreatedAppAsset/data/AppCall.clear.teal   |   7 +
 .../data/StateMutations.approval.teal         | 766 ++++++++++++++++++
 .../data/StateMutations.arc32.json            |  95 +++
 .../data/StateMutations.clear.teal            |   7 +
 6 files changed, 983 insertions(+)
 create mode 100644 tests/artifacts/CreatedAppAsset/data/AppCall.approval.teal
 create mode 100644 tests/artifacts/CreatedAppAsset/data/AppCall.arc32.json
 create mode 100644 tests/artifacts/CreatedAppAsset/data/AppCall.clear.teal
 create mode 100644 tests/artifacts/StateMutations/data/StateMutations.approval.teal
 create mode 100644 tests/artifacts/StateMutations/data/StateMutations.arc32.json
 create mode 100644 tests/artifacts/StateMutations/data/StateMutations.clear.teal

diff --git a/tests/artifacts/CreatedAppAsset/data/AppCall.approval.teal b/tests/artifacts/CreatedAppAsset/data/AppCall.approval.teal
new file mode 100644
index 0000000..2d7352c
--- /dev/null
+++ b/tests/artifacts/CreatedAppAsset/data/AppCall.approval.teal
@@ -0,0 +1,58 @@
+#pragma version 10
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.approval_program() -> uint64:
+main:
+    // tests/artifacts/CreatedAppAsset/other.py:4
+    // class AppCall(ARC4Contract):
+    txn NumAppArgs
+    bz main_bare_routing@6
+    pushbytes 0xd3479e65 // method "some_value()uint64"
+    txna ApplicationArgs 0
+    match main_some_value_route@3
+
+main_after_if_else@10:
+    // tests/artifacts/CreatedAppAsset/other.py:4
+    // class AppCall(ARC4Contract):
+    pushint 0 // 0
+    return
+
+main_some_value_route@3:
+    // tests/artifacts/CreatedAppAsset/other.py:5
+    // @arc4.abimethod()
+    txn OnCompletion
+    !
+    assert // OnCompletion is not NoOp
+    txn ApplicationID
+    assert // can only call when not creating
+    callsub some_value
+    itob
+    pushbytes 0x151f7c75
+    swap
+    concat
+    log
+    pushint 1 // 1
+    return
+
+main_bare_routing@6:
+    // tests/artifacts/CreatedAppAsset/other.py:4
+    // class AppCall(ARC4Contract):
+    txn OnCompletion
+    bnz main_after_if_else@10
+    txn ApplicationID
+    !
+    assert // can only call when creating
+    pushint 1 // 1
+    return
+
+
+// tests.artifacts.CreatedAppAsset.other.AppCall.some_value() -> uint64:
+some_value:
+    // tests/artifacts/CreatedAppAsset/other.py:7
+    // return Global.group_size * (Txn.group_index + 1)
+    global GroupSize
+    txn GroupIndex
+    pushint 1 // 1
+    +
+    *
+    retsub
diff --git a/tests/artifacts/CreatedAppAsset/data/AppCall.arc32.json b/tests/artifacts/CreatedAppAsset/data/AppCall.arc32.json
new file mode 100644
index 0000000..cc5d3ba
--- /dev/null
+++ b/tests/artifacts/CreatedAppAsset/data/AppCall.arc32.json
@@ -0,0 +1,50 @@
+{
+    "hints": {
+        "some_value()uint64": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        }
+    },
+    "source": {
+        "approval": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuYXBwcm92YWxfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvb3RoZXIucHk6NAogICAgLy8gY2xhc3MgQXBwQ2FsbChBUkM0Q29udHJhY3QpOgogICAgdHhuIE51bUFwcEFyZ3MKICAgIGJ6IG1haW5fYmFyZV9yb3V0aW5nQDYKICAgIHB1c2hieXRlcyAweGQzNDc5ZTY1IC8vIG1ldGhvZCAic29tZV92YWx1ZSgpdWludDY0IgogICAgdHhuYSBBcHBsaWNhdGlvbkFyZ3MgMAogICAgbWF0Y2ggbWFpbl9zb21lX3ZhbHVlX3JvdXRlQDMKCm1haW5fYWZ0ZXJfaWZfZWxzZUAxMDoKICAgIC8vIHRlc3RzL2FydGlmYWN0cy9DcmVhdGVkQXBwQXNzZXQvb3RoZXIucHk6NAogICAgLy8gY2xhc3MgQXBwQ2FsbChBUkM0Q29udHJhY3QpOgogICAgcHVzaGludCAwIC8vIDAKICAgIHJldHVybgoKbWFpbl9zb21lX3ZhbHVlX3JvdXRlQDM6CiAgICAvLyB0ZXN0cy9hcnRpZmFjdHMvQ3JlYXRlZEFwcEFzc2V0L290aGVyLnB5OjUKICAgIC8vIEBhcmM0LmFiaW1ldGhvZCgpCiAgICB0eG4gT25Db21wbGV0aW9uCiAgICAhCiAgICBhc3NlcnQgLy8gT25Db21wbGV0aW9uIGlzIG5vdCBOb09wCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgYXNzZXJ0IC8vIGNhbiBvbmx5IGNhbGwgd2hlbiBub3QgY3JlYXRpbmcKICAgIGNhbGxzdWIgc29tZV92YWx1ZQogICAgaXRvYgogICAgcHVzaGJ5dGVzIDB4MTUxZjdjNzUKICAgIHN3YXAKICAgIGNvbmNhdAogICAgbG9nCiAgICBwdXNoaW50IDEgLy8gMQogICAgcmV0dXJuCgptYWluX2JhcmVfcm91dGluZ0A2OgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9vdGhlci5weTo0CiAgICAvLyBjbGFzcyBBcHBDYWxsKEFSQzRDb250cmFjdCk6CiAgICB0eG4gT25Db21wbGV0aW9uCiAgICBibnogbWFpbl9hZnRlcl9pZl9lbHNlQDEwCiAgICB0eG4gQXBwbGljYXRpb25JRAogICAgIQogICAgYXNzZXJ0IC8vIGNhbiBvbmx5IGNhbGwgd2hlbiBjcmVhdGluZwogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgoKCi8vIHRlc3RzLmFydGlmYWN0cy5DcmVhdGVkQXBwQXNzZXQub3RoZXIuQXBwQ2FsbC5zb21lX3ZhbHVlKCkgLT4gdWludDY0Ogpzb21lX3ZhbHVlOgogICAgLy8gdGVzdHMvYXJ0aWZhY3RzL0NyZWF0ZWRBcHBBc3NldC9vdGhlci5weTo3CiAgICAvLyByZXR1cm4gR2xvYmFsLmdyb3VwX3NpemUgKiAoVHhuLmdyb3VwX2luZGV4ICsgMSkKICAgIGdsb2JhbCBHcm91cFNpemUKICAgIHR4biBHcm91cEluZGV4CiAgICBwdXNoaW50IDEgLy8gMQogICAgKwogICAgKgogICAgcmV0c3ViCg==",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "state": {
+        "global": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        },
+        "local": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        }
+    },
+    "schema": {
+        "global": {
+            "declared": {},
+            "reserved": {}
+        },
+        "local": {
+            "declared": {},
+            "reserved": {}
+        }
+    },
+    "contract": {
+        "name": "AppCall",
+        "methods": [
+            {
+                "name": "some_value",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64"
+                }
+            }
+        ],
+        "networks": {}
+    },
+    "bare_call_config": {
+        "no_op": "CREATE"
+    }
+}
\ No newline at end of file
diff --git a/tests/artifacts/CreatedAppAsset/data/AppCall.clear.teal b/tests/artifacts/CreatedAppAsset/data/AppCall.clear.teal
new file mode 100644
index 0000000..a433105
--- /dev/null
+++ b/tests/artifacts/CreatedAppAsset/data/AppCall.clear.teal
@@ -0,0 +1,7 @@
+#pragma version 10
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
+    return
diff --git a/tests/artifacts/StateMutations/data/StateMutations.approval.teal b/tests/artifacts/StateMutations/data/StateMutations.approval.teal
new file mode 100644
index 0000000..97187f1
--- /dev/null
+++ b/tests/artifacts/StateMutations/data/StateMutations.approval.teal
@@ -0,0 +1,766 @@
+#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
diff --git a/tests/artifacts/StateMutations/data/StateMutations.arc32.json b/tests/artifacts/StateMutations/data/StateMutations.arc32.json
new file mode 100644
index 0000000..05f7b77
--- /dev/null
+++ b/tests/artifacts/StateMutations/data/StateMutations.arc32.json
@@ -0,0 +1,95 @@
+{
+    "hints": {
+        "append()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "modify()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "get()(uint64,string)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        }
+    },
+    "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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "state": {
+        "global": {
+            "num_byte_slices": 3,
+            "num_uints": 0
+        },
+        "local": {
+            "num_byte_slices": 1,
+            "num_uints": 0
+        }
+    },
+    "schema": {
+        "global": {
+            "declared": {
+                "glob": {
+                    "type": "bytes",
+                    "key": "glob"
+                },
+                "glob_assign": {
+                    "type": "bytes",
+                    "key": "glob_assign"
+                },
+                "no_proxy": {
+                    "type": "bytes",
+                    "key": "no_proxy"
+                }
+            },
+            "reserved": {}
+        },
+        "local": {
+            "declared": {
+                "loc": {
+                    "type": "bytes",
+                    "key": "loc"
+                }
+            },
+            "reserved": {}
+        }
+    },
+    "contract": {
+        "name": "StateMutations",
+        "methods": [
+            {
+                "name": "append",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "modify",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "get",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,string)[]"
+                }
+            }
+        ],
+        "networks": {}
+    },
+    "bare_call_config": {
+        "opt_in": "CALL",
+        "no_op": "CREATE"
+    }
+}
\ No newline at end of file
diff --git a/tests/artifacts/StateMutations/data/StateMutations.clear.teal b/tests/artifacts/StateMutations/data/StateMutations.clear.teal
new file mode 100644
index 0000000..a433105
--- /dev/null
+++ b/tests/artifacts/StateMutations/data/StateMutations.clear.teal
@@ -0,0 +1,7 @@
+#pragma version 10
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
+    return

From db671938d56a0c25973dfc7acb20341904fb6081 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Mon, 17 Feb 2025 09:56:42 +0800
Subject: [PATCH 21/23] test: add array test artifacts

---
 tests/artifacts/Arrays/__init__.py            |    0
 .../Arrays/data/Contract.approval.teal        | 1675 ++++++++
 .../artifacts/Arrays/data/Contract.arc32.json |  172 +
 .../artifacts/Arrays/data/Contract.clear.teal |    7 +
 .../data/ImmutableArrayContract.approval.teal | 3421 +++++++++++++++++
 .../data/ImmutableArrayContract.arc32.json    |  450 +++
 .../data/ImmutableArrayContract.clear.teal    |    7 +
 .../data/StaticSizeContract.approval.teal     |  902 +++++
 .../Arrays/data/StaticSizeContract.arc32.json |  162 +
 .../Arrays/data/StaticSizeContract.clear.teal |    7 +
 tests/artifacts/Arrays/immutable.py           |  428 +++
 tests/artifacts/Arrays/static_size.py         |  135 +
 tests/artifacts/Arrays/uint64.py              |  255 ++
 13 files changed, 7621 insertions(+)
 create mode 100644 tests/artifacts/Arrays/__init__.py
 create mode 100644 tests/artifacts/Arrays/data/Contract.approval.teal
 create mode 100644 tests/artifacts/Arrays/data/Contract.arc32.json
 create mode 100644 tests/artifacts/Arrays/data/Contract.clear.teal
 create mode 100644 tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal
 create mode 100644 tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json
 create mode 100644 tests/artifacts/Arrays/data/ImmutableArrayContract.clear.teal
 create mode 100644 tests/artifacts/Arrays/data/StaticSizeContract.approval.teal
 create mode 100644 tests/artifacts/Arrays/data/StaticSizeContract.arc32.json
 create mode 100644 tests/artifacts/Arrays/data/StaticSizeContract.clear.teal
 create mode 100644 tests/artifacts/Arrays/immutable.py
 create mode 100644 tests/artifacts/Arrays/static_size.py
 create mode 100644 tests/artifacts/Arrays/uint64.py

diff --git a/tests/artifacts/Arrays/__init__.py b/tests/artifacts/Arrays/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/artifacts/Arrays/data/Contract.approval.teal b/tests/artifacts/Arrays/data/Contract.approval.teal
new file mode 100644
index 0000000..54ffaef
--- /dev/null
+++ b/tests/artifacts/Arrays/data/Contract.approval.teal
@@ -0,0 +1,1675 @@
+#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
+    -
+    dig 2
+    callsub append_length_and_return
+    loads
+    extract 0 8
+    intc_1 // 0
+    extract_uint64
+    dig 3
+    loads
+    uncover 2
+    intc_0 // 8
+    *
+    uncover 3
+    swap
+    intc_0 // 8
+    extract3
+    intc_1 // 0
+    extract_uint64
+    uncover 2
+    intc_0 // 8
+    *
+    swap
+    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
+    dup
+    len
+    intc_1 // 0
+
+test_quicksort_for_header@1:
+    // tests/artifacts/Arrays/uint64.py:160
+    // for b in Txn.sender.bytes:
+    frame_dig 6
+    frame_dig 5
+    <
+    bz test_quicksort_after_for@4
+    // tests/artifacts/Arrays/uint64.py:161
+    // rnd.append(op.btoi(b))
+    frame_dig 4
+    frame_dig 6
+    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 6
+    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
diff --git a/tests/artifacts/Arrays/data/Contract.arc32.json b/tests/artifacts/Arrays/data/Contract.arc32.json
new file mode 100644
index 0000000..f77d807
--- /dev/null
+++ b/tests/artifacts/Arrays/data/Contract.arc32.json
@@ -0,0 +1,172 @@
+{
+    "hints": {
+        "test_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_array_extend()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_array_multiple_append()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "overhead()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_array_too_long()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_array_copy_and_extend()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_array_evaluation_order()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_allocations(uint64)void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_iteration()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_quicksort()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
    -
    dig 2
    callsub append_length_and_return
    loads
    extract 0 8
    intc_1 // 0
    extract_uint64
    dig 3
    loads
    uncover 2
    intc_0 // 8
    *
    uncover 3
    swap
    intc_0 // 8
    extract3
    intc_1 // 0
    extract_uint64
    uncover 2
    intc_0 // 8
    *
    swap
    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
    dup
    len
    intc_1 // 0

test_quicksort_for_header@1:
    // tests/artifacts/Arrays/uint64.py:160
    // for b in Txn.sender.bytes:
    frame_dig 6
    frame_dig 5
    <
    bz test_quicksort_after_for@4
    // tests/artifacts/Arrays/uint64.py:161
    // rnd.append(op.btoi(b))
    frame_dig 4
    frame_dig 6
    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 6
    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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "state": {
+        "global": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        },
+        "local": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        }
+    },
+    "schema": {
+        "global": {
+            "declared": {},
+            "reserved": {}
+        },
+        "local": {
+            "declared": {},
+            "reserved": {}
+        }
+    },
+    "contract": {
+        "name": "Contract",
+        "methods": [
+            {
+                "name": "test_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_array_extend",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_array_multiple_append",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "overhead",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_array_too_long",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_array_copy_and_extend",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_array_evaluation_order",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_allocations",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "num"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_iteration",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_quicksort",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            }
+        ],
+        "networks": {}
+    },
+    "bare_call_config": {
+        "no_op": "CREATE"
+    }
+}
\ No newline at end of file
diff --git a/tests/artifacts/Arrays/data/Contract.clear.teal b/tests/artifacts/Arrays/data/Contract.clear.teal
new file mode 100644
index 0000000..a433105
--- /dev/null
+++ b/tests/artifacts/Arrays/data/Contract.clear.teal
@@ -0,0 +1,7 @@
+#pragma version 10
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
+    return
diff --git a/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal b/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal
new file mode 100644
index 0000000..28edb37
--- /dev/null
+++ b/tests/artifacts/Arrays/data/ImmutableArrayContract.approval.teal
@@ -0,0 +1,3421 @@
+#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
diff --git a/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json b/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json
new file mode 100644
index 0000000..59f79d1
--- /dev/null
+++ b/tests/artifacts/Arrays/data/ImmutableArrayContract.arc32.json
@@ -0,0 +1,450 @@
+{
+    "hints": {
+        "test_uint64_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_bool_array(uint64)void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_fixed_size_tuple_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_fixed_size_named_tuple_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_dynamic_sized_tuple_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_dynamic_sized_named_tuple_array()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_implicit_conversion_log(uint64[])void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_implicit_conversion_emit(uint64[])void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_nested_array(uint64,uint64[][])uint64[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_bit_packed_tuples()void": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "sum_uints_and_lengths_and_trues(uint64[],bool[],(uint64,bool,bool)[],(uint64,string)[])(uint64,uint64,uint64,uint64)": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_uint64_return(uint64)uint64[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_bool_return(uint64)bool[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_tuple_return(uint64)(uint64,bool,bool)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_dynamic_tuple_return(uint64)(uint64,string)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_convert_to_array_and_back((uint64,bool,bool)[],uint64)(uint64,bool,bool)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_concat_with_arc4_tuple((uint64,uint64))uint64[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_concat_with_native_tuple((uint64,uint64))uint64[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_dynamic_concat_with_arc4_tuple((string,string))string[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_dynamic_concat_with_native_tuple((string,string))string[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_concat_immutable_dynamic((uint64,string)[],(uint64,string)[])(uint64,string)[]": {
+            "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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "state": {
+        "global": {
+            "num_byte_slices": 10,
+            "num_uints": 0
+        },
+        "local": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        }
+    },
+    "schema": {
+        "global": {
+            "declared": {
+                "a": {
+                    "type": "bytes",
+                    "key": "a"
+                },
+                "bool2": {
+                    "type": "bytes",
+                    "key": "bool2"
+                },
+                "bool7": {
+                    "type": "bytes",
+                    "key": "bool7"
+                },
+                "bool8": {
+                    "type": "bytes",
+                    "key": "bool8"
+                },
+                "bool9": {
+                    "type": "bytes",
+                    "key": "bool9"
+                },
+                "c": {
+                    "type": "bytes",
+                    "key": "c"
+                },
+                "d": {
+                    "type": "bytes",
+                    "key": "d"
+                },
+                "e": {
+                    "type": "bytes",
+                    "key": "e"
+                },
+                "f": {
+                    "type": "bytes",
+                    "key": "f"
+                },
+                "g": {
+                    "type": "bytes",
+                    "key": "g"
+                }
+            },
+            "reserved": {}
+        },
+        "local": {
+            "declared": {},
+            "reserved": {}
+        }
+    },
+    "contract": {
+        "name": "ImmutableArrayContract",
+        "methods": [
+            {
+                "name": "test_uint64_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_bool_array",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "length"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_fixed_size_tuple_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_fixed_size_named_tuple_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_dynamic_sized_tuple_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_dynamic_sized_named_tuple_array",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_implicit_conversion_log",
+                "args": [
+                    {
+                        "type": "uint64[]",
+                        "name": "arr"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_implicit_conversion_emit",
+                "args": [
+                    {
+                        "type": "uint64[]",
+                        "name": "arr"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "test_nested_array",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "arr_to_add"
+                    },
+                    {
+                        "type": "uint64[][]",
+                        "name": "arr"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64[]"
+                }
+            },
+            {
+                "name": "test_bit_packed_tuples",
+                "args": [],
+                "readonly": false,
+                "returns": {
+                    "type": "void"
+                }
+            },
+            {
+                "name": "sum_uints_and_lengths_and_trues",
+                "args": [
+                    {
+                        "type": "uint64[]",
+                        "name": "arr1"
+                    },
+                    {
+                        "type": "bool[]",
+                        "name": "arr2"
+                    },
+                    {
+                        "type": "(uint64,bool,bool)[]",
+                        "name": "arr3"
+                    },
+                    {
+                        "type": "(uint64,string)[]",
+                        "name": "arr4"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64,uint64,uint64)"
+                }
+            },
+            {
+                "name": "test_uint64_return",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "append"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64[]"
+                }
+            },
+            {
+                "name": "test_bool_return",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "append"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "bool[]"
+                }
+            },
+            {
+                "name": "test_tuple_return",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "append"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,bool,bool)[]"
+                }
+            },
+            {
+                "name": "test_dynamic_tuple_return",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "append"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,string)[]"
+                }
+            },
+            {
+                "name": "test_convert_to_array_and_back",
+                "args": [
+                    {
+                        "type": "(uint64,bool,bool)[]",
+                        "name": "arr"
+                    },
+                    {
+                        "type": "uint64",
+                        "name": "append"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,bool,bool)[]"
+                }
+            },
+            {
+                "name": "test_concat_with_arc4_tuple",
+                "args": [
+                    {
+                        "type": "(uint64,uint64)",
+                        "name": "arg"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64[]"
+                }
+            },
+            {
+                "name": "test_concat_with_native_tuple",
+                "args": [
+                    {
+                        "type": "(uint64,uint64)",
+                        "name": "arg"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64[]"
+                }
+            },
+            {
+                "name": "test_dynamic_concat_with_arc4_tuple",
+                "args": [
+                    {
+                        "type": "(string,string)",
+                        "name": "arg"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "string[]"
+                }
+            },
+            {
+                "name": "test_dynamic_concat_with_native_tuple",
+                "args": [
+                    {
+                        "type": "(string,string)",
+                        "name": "arg"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "string[]"
+                }
+            },
+            {
+                "name": "test_concat_immutable_dynamic",
+                "args": [
+                    {
+                        "type": "(uint64,string)[]",
+                        "name": "imm1"
+                    },
+                    {
+                        "type": "(uint64,string)[]",
+                        "name": "imm2"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,string)[]"
+                }
+            }
+        ],
+        "networks": {}
+    },
+    "bare_call_config": {
+        "no_op": "CREATE"
+    }
+}
\ No newline at end of file
diff --git a/tests/artifacts/Arrays/data/ImmutableArrayContract.clear.teal b/tests/artifacts/Arrays/data/ImmutableArrayContract.clear.teal
new file mode 100644
index 0000000..a433105
--- /dev/null
+++ b/tests/artifacts/Arrays/data/ImmutableArrayContract.clear.teal
@@ -0,0 +1,7 @@
+#pragma version 10
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
+    return
diff --git a/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal b/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal
new file mode 100644
index 0000000..b35abc3
--- /dev/null
+++ b/tests/artifacts/Arrays/data/StaticSizeContract.approval.teal
@@ -0,0 +1,902 @@
+#pragma version 10
+#pragma typetrack false
+
+// tests.artifacts.Arrays.static_size.StaticSizeContract.__algopy_entrypoint_with_init() -> uint64:
+main:
+    intcblock 1 0 8 16
+    bytecblock "count" 0x151f7c75 "" "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
+    pushint 80 // 80
+    *
+    pushint 80 // 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
+    pushint 80 // 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
+    pushint 80 // 80
+    *
+    pushint 80 // 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
+    intc_3 // 16
+    /
+    dup
+    intc_0 // 1
+    -
+    intc_3 // 16
+    *
+    dig 2
+    swap
+    intc_3 // 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
+    intc_3 // 16
+    *
+    intc_3 // 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()
+    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: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
+    intc_0 // 1
+    /
+    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
+    getbyte
+    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:
+    pushbytes 0x0000000000000000
+    !=
+    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
diff --git a/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json b/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json
new file mode 100644
index 0000000..6c3928b
--- /dev/null
+++ b/tests/artifacts/Arrays/data/StaticSizeContract.arc32.json
@@ -0,0 +1,162 @@
+{
+    "hints": {
+        "test_array(uint64,uint64,uint64,uint64)uint64": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_extend_from_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_extend_from_arc4_tuple(((uint64,uint64),(uint64,uint64)))(uint64,uint64)[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_bool_array(uint64)uint64": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "test_arc4_conversion(uint64)uint64[]": {
+            "call_config": {
+                "no_op": "CALL"
+            }
+        },
+        "sum_array(uint64[])uint64": {
+            "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 16
    bytecblock "count" 0x151f7c75 "" "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
    pushint 80 // 80
    *
    pushint 80 // 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
    pushint 80 // 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
    pushint 80 // 80
    *
    pushint 80 // 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
    intc_3 // 16
    /
    dup
    intc_0 // 1
    -
    intc_3 // 16
    *
    dig 2
    swap
    intc_3 // 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
    intc_3 // 16
    *
    intc_3 // 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()
    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: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
    intc_0 // 1
    /
    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
    getbyte
    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:
    pushbytes 0x0000000000000000
    !=
    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
",
+        "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCiNwcmFnbWEgdHlwZXRyYWNrIGZhbHNlCgovLyBhbGdvcHkuYXJjNC5BUkM0Q29udHJhY3QuY2xlYXJfc3RhdGVfcHJvZ3JhbSgpIC0+IHVpbnQ2NDoKbWFpbjoKICAgIHB1c2hpbnQgMSAvLyAxCiAgICByZXR1cm4K"
+    },
+    "state": {
+        "global": {
+            "num_byte_slices": 0,
+            "num_uints": 1
+        },
+        "local": {
+            "num_byte_slices": 0,
+            "num_uints": 0
+        }
+    },
+    "schema": {
+        "global": {
+            "declared": {
+                "count": {
+                    "type": "uint64",
+                    "key": "count"
+                }
+            },
+            "reserved": {}
+        },
+        "local": {
+            "declared": {},
+            "reserved": {}
+        }
+    },
+    "contract": {
+        "name": "StaticSizeContract",
+        "methods": [
+            {
+                "name": "test_array",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "x1"
+                    },
+                    {
+                        "type": "uint64",
+                        "name": "y1"
+                    },
+                    {
+                        "type": "uint64",
+                        "name": "x2"
+                    },
+                    {
+                        "type": "uint64",
+                        "name": "y2"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64"
+                }
+            },
+            {
+                "name": "test_extend_from_tuple",
+                "args": [
+                    {
+                        "type": "((uint64,uint64),(uint64,uint64))",
+                        "name": "some_more"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64)[]"
+                }
+            },
+            {
+                "name": "test_extend_from_arc4_tuple",
+                "args": [
+                    {
+                        "type": "((uint64,uint64),(uint64,uint64))",
+                        "name": "some_more"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "(uint64,uint64)[]"
+                }
+            },
+            {
+                "name": "test_bool_array",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "length"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64"
+                }
+            },
+            {
+                "name": "test_arc4_conversion",
+                "args": [
+                    {
+                        "type": "uint64",
+                        "name": "length"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64[]"
+                }
+            },
+            {
+                "name": "sum_array",
+                "args": [
+                    {
+                        "type": "uint64[]",
+                        "name": "arc4_arr"
+                    }
+                ],
+                "readonly": false,
+                "returns": {
+                    "type": "uint64"
+                }
+            }
+        ],
+        "networks": {}
+    },
+    "bare_call_config": {
+        "no_op": "CREATE"
+    }
+}
\ No newline at end of file
diff --git a/tests/artifacts/Arrays/data/StaticSizeContract.clear.teal b/tests/artifacts/Arrays/data/StaticSizeContract.clear.teal
new file mode 100644
index 0000000..a433105
--- /dev/null
+++ b/tests/artifacts/Arrays/data/StaticSizeContract.clear.teal
@@ -0,0 +1,7 @@
+#pragma version 10
+#pragma typetrack false
+
+// algopy.arc4.ARC4Contract.clear_state_program() -> uint64:
+main:
+    pushint 1 // 1
+    return
diff --git a/tests/artifacts/Arrays/immutable.py b/tests/artifacts/Arrays/immutable.py
new file mode 100644
index 0000000..cc52abb
--- /dev/null
+++ b/tests/artifacts/Arrays/immutable.py
@@ -0,0 +1,428 @@
+import typing
+
+from algopy import (
+    Array,
+    Bytes,
+    ImmutableArray,
+    String,
+    Txn,
+    UInt64,
+    arc4,
+    log,
+    op,
+    subroutine,
+    uenumerate,
+    urange,
+)
+
+
+class MyTuple(typing.NamedTuple):
+    foo: UInt64
+    bar: bool
+    baz: bool
+
+
+class MyDynamicSizedTuple(typing.NamedTuple):
+    foo: UInt64
+    bar: String
+
+
+class TwoBoolTuple(typing.NamedTuple):
+    a: bool
+    b: bool
+
+
+class SevenBoolTuple(typing.NamedTuple):
+    foo: UInt64
+    a: bool
+    b: bool
+    c: bool
+    d: bool
+    e: bool
+    f: bool
+    g: bool
+    bar: UInt64
+
+
+class EightBoolTuple(typing.NamedTuple):
+    foo: UInt64
+    a: bool
+    b: bool
+    c: bool
+    d: bool
+    e: bool
+    f: bool
+    g: bool
+    h: bool
+    bar: UInt64
+
+
+class NineBoolTuple(typing.NamedTuple):
+    foo: UInt64
+    a: bool
+    b: bool
+    c: bool
+    d: bool
+    e: bool
+    f: bool
+    g: bool
+    h: bool
+    i: bool
+    bar: UInt64
+
+
+class ImmutableArrayContract(arc4.ARC4Contract):
+    @arc4.abimethod()
+    def test_uint64_array(self) -> None:
+        arr = ImmutableArray[UInt64]()
+        assert arr.length == 0
+
+        arr = arr.append(UInt64(42))
+        assert arr.length == 1
+        assert arr[-1] == 42
+
+        arr = add_x(arr, UInt64(5))
+        assert arr.length == 6
+        assert arr[-1] == 4
+
+        arr = arr.append(UInt64(43))
+        assert arr.length == 7
+        assert arr[-1] == 43
+        assert arr[0] == 42
+
+        arr = pop_x(arr, UInt64(3))
+        assert arr.length == 4
+        assert arr[-1] == 2
+
+        arr = add_x(arr, UInt64(10))
+        assert arr.length == 14
+        assert arr[-1] == 9
+
+        arr = arr.append(UInt64(44))
+        assert arr.length == 15
+        assert arr[-1] == 44
+
+        arr = arr.replace(2, UInt64(23))
+        assert arr.length == 15
+        assert arr[2] == 23
+
+        self.a = arr
+
+    @arc4.abimethod()
+    def test_bool_array(self, length: UInt64) -> None:
+        arr = ImmutableArray[bool]()
+        assert arr.length == 0
+
+        for i in urange(length):
+            arr = arr.append(i == Txn.num_app_args)
+
+        assert arr.length == length
+
+        if length > 0:
+            assert not arr[0], "expected element 0 to be False"
+        if length > 1:
+            assert not arr[1], "expected element 1 to be False"
+        if length > 2:
+            assert arr[2], "expected element 2 to be True"
+        if length > 3:
+            assert not arr[length - 1], "expected last element to be False"
+
+        self.g = arr
+        if length:
+            arr = arr.pop()
+            assert arr.length == length - 1
+
+    @arc4.abimethod()
+    def test_fixed_size_tuple_array(self) -> None:
+        arr = ImmutableArray[tuple[UInt64, UInt64]]()
+        assert arr.length == 0
+
+        for i in urange(5):
+            arr = arr.append((i + 1, i + 2))
+
+        assert arr.length == 5
+        assert arr[0] == (UInt64(1), UInt64(2))
+        assert arr[-1] == (UInt64(5), UInt64(6))
+
+        arr = arr.pop()
+        assert arr.length == 4
+        assert arr[0] == (UInt64(1), UInt64(2))
+        assert arr[-1] == (UInt64(4), UInt64(5))
+        self.c = arr
+
+    @arc4.abimethod()
+    def test_fixed_size_named_tuple_array(self) -> None:
+        arr = ImmutableArray[MyTuple]()
+        assert arr.length == 0
+
+        for i in urange(5):
+            arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i * 3 % 2 == 0))
+
+        assert arr.length == 5
+        foo, bar, baz = arr[0]
+        assert foo == 0
+        assert bar
+        assert baz
+        self.d = arr
+
+    @arc4.abimethod()
+    def test_dynamic_sized_tuple_array(self) -> None:
+        arr = ImmutableArray[tuple[UInt64, Bytes]]()
+        assert arr.length == 0
+
+        for i in urange(5):
+            arr = arr.append((i + 1, op.bzero(i)))
+
+        assert arr.length == 5
+        for i in urange(5):
+            assert arr[i][0] == i + 1, "expected 1st element to be correct"
+            assert arr[i][1].length == i, "expected 2nd element to be correct"
+
+        arr = arr.pop()
+        assert arr.length == 4
+        assert arr[0] == (UInt64(1), op.bzero(0)), "expected 1, 0"
+        assert arr[-1] == (UInt64(4), op.bzero(3)), "expected 4, 3"
+        self.e = arr
+
+    @arc4.abimethod()
+    def test_dynamic_sized_named_tuple_array(self) -> None:
+        arr = ImmutableArray[MyDynamicSizedTuple]()
+        assert arr.length == 0
+
+        for i in urange(5):
+            arr = arr.append(MyDynamicSizedTuple(foo=i + 1, bar=times(i)))
+
+        assert arr.length == 5
+        for i in urange(5):
+            assert arr[i][0] == i + 1, "expected 1st element to be correct"
+            assert arr[i][1] == times(i), "expected 2nd element to be correct"
+
+        arr = arr.pop()
+        assert arr.length == 4
+        assert arr[0] == MyDynamicSizedTuple(UInt64(1), String()), "expected 1, 0"
+        assert arr[-1] == MyDynamicSizedTuple(UInt64(4), String("   ")), "expected 4, 3"
+        self.f = arr
+
+    @arc4.abimethod()
+    def test_implicit_conversion_log(self, arr: ImmutableArray[UInt64]) -> None:
+        log(arr)
+
+    @arc4.abimethod()
+    def test_implicit_conversion_emit(self, arr: ImmutableArray[UInt64]) -> None:
+        arc4.emit("emit_test", arr)
+
+    @arc4.abimethod()
+    def test_nested_array(
+        self, arr_to_add: UInt64, arr: ImmutableArray[ImmutableArray[UInt64]]
+    ) -> ImmutableArray[UInt64]:
+        # add n new arrays
+        for i in urange(arr_to_add):
+            extra_arr = ImmutableArray[UInt64]()
+            for j in urange(i):
+                extra_arr = extra_arr.append(j)
+            arr = arr.append(extra_arr)
+
+        # sum inner arrays and return an array containing sums
+        totals = ImmutableArray[UInt64]()
+        for inner_arr in arr:
+            totals = totals.append(sum_arr(inner_arr))
+
+        return totals
+
+    @arc4.abimethod()
+    def test_bit_packed_tuples(self) -> None:
+        arr2 = ImmutableArray[TwoBoolTuple]()
+        arr7 = ImmutableArray[SevenBoolTuple]()
+        arr8 = ImmutableArray[EightBoolTuple]()
+        arr9 = ImmutableArray[NineBoolTuple]()
+        assert arr2.length == 0
+        assert arr7.length == 0
+        assert arr8.length == 0
+        assert arr9.length == 0
+
+        for i in urange(5):
+            arr2 = arr2.append(TwoBoolTuple(a=i == 0, b=i == 1))
+            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,
+                )
+            )
+            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,
+                )
+            )
+            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,
+                )
+            )
+
+        assert arr2.length == 5
+        assert arr7.length == 5
+        assert arr8.length == 5
+        assert arr9.length == 5
+        self.bool2 = arr2
+        self.bool7 = arr7
+        self.bool8 = arr8
+        self.bool9 = arr9
+
+    @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]:
+        sum1 = sum2 = sum3 = sum4 = UInt64()
+        for i in arr1:
+            sum1 += i
+        for b in arr2:
+            if b:
+                sum2 += 1
+        for tup in arr3:
+            sum3 += tup.foo
+            if tup.bar:
+                sum3 += 1
+            if tup.baz:
+                sum3 += 1
+        for idx, dyn_tup in uenumerate(arr4):
+            sum4 += dyn_tup.foo
+            sum4 += dyn_tup.bar.bytes.length
+            assert dyn_tup.bar.bytes.length == idx, "expected string length to match index"
+
+        return sum1, sum2, sum3, sum4
+
+    @arc4.abimethod()
+    def test_uint64_return(self, append: UInt64) -> ImmutableArray[UInt64]:
+        arr = ImmutableArray(UInt64(1), UInt64(2), UInt64(3))
+        for i in urange(append):
+            arr = arr.append(i)
+        return arr
+
+    @arc4.abimethod()
+    def test_bool_return(self, append: UInt64) -> ImmutableArray[bool]:
+        arr = ImmutableArray(True, False, True, False, True)
+        for i in urange(append):
+            arr = arr.append(i % 2 == 0)
+        return arr
+
+    @arc4.abimethod()
+    def test_tuple_return(self, append: UInt64) -> ImmutableArray[MyTuple]:
+        arr = ImmutableArray(MyTuple(UInt64(), True, False))
+        for i in urange(append):
+            arr = arr.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
+        return arr
+
+    @arc4.abimethod()
+    def test_dynamic_tuple_return(self, append: UInt64) -> ImmutableArray[MyDynamicSizedTuple]:
+        arr = ImmutableArray(MyDynamicSizedTuple(UInt64(), String("Hello")))
+        for i in urange(append):
+            arr = arr.append(MyDynamicSizedTuple(i, times(i)))
+        return arr
+
+    @arc4.abimethod()
+    def test_convert_to_array_and_back(
+        self, arr: ImmutableArray[MyTuple], append: UInt64
+    ) -> ImmutableArray[MyTuple]:
+        mutable = Array[MyTuple]()
+        mutable.extend(arr)
+        for i in urange(append):
+            mutable.append(MyTuple(foo=i, bar=i % 2 == 0, baz=i % 3 == 0))
+        return mutable.freeze()
+
+    @arc4.abimethod()
+    def test_concat_with_arc4_tuple(
+        self, arg: arc4.Tuple[arc4.UInt64, arc4.UInt64]
+    ) -> ImmutableArray[arc4.UInt64]:
+        prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
+        result = prefix + arg
+        return result
+
+    @arc4.abimethod()
+    def test_concat_with_native_tuple(
+        self, arg: tuple[arc4.UInt64, arc4.UInt64]
+    ) -> ImmutableArray[arc4.UInt64]:
+        prefix = ImmutableArray(arc4.UInt64(1), arc4.UInt64(2))
+        result = prefix + arg
+        return result
+
+    @arc4.abimethod()
+    def test_dynamic_concat_with_arc4_tuple(
+        self, arg: arc4.Tuple[arc4.String, arc4.String]
+    ) -> ImmutableArray[arc4.String]:
+        prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
+        result = prefix + arg
+        return result
+
+    @arc4.abimethod()
+    def test_dynamic_concat_with_native_tuple(
+        self, arg: tuple[arc4.String, arc4.String]
+    ) -> ImmutableArray[arc4.String]:
+        prefix = ImmutableArray(arc4.String("a"), arc4.String("b"))
+        result = prefix + arg
+        return result
+
+    @arc4.abimethod()
+    def test_concat_immutable_dynamic(
+        self, imm1: ImmutableArray[MyDynamicSizedTuple], imm2: ImmutableArray[MyDynamicSizedTuple]
+    ) -> ImmutableArray[MyDynamicSizedTuple]:
+        return imm1 + imm2
+
+
+@subroutine
+def times(n: UInt64) -> String:
+    result = String()
+    for _i in urange(n):
+        result += String(" ")
+    return result
+
+
+@subroutine
+def add_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
+    for i in urange(x):
+        arr = arr.append(i)
+    return arr
+
+
+@subroutine
+def pop_x(arr: ImmutableArray[UInt64], x: UInt64) -> ImmutableArray[UInt64]:
+    for _i in urange(x):
+        arr = arr.pop()
+    return arr
+
+
+@subroutine
+def sum_arr(arr: ImmutableArray[UInt64]) -> UInt64:
+    total = UInt64()
+    for i in arr:
+        total += i
+    return total
diff --git a/tests/artifacts/Arrays/static_size.py b/tests/artifacts/Arrays/static_size.py
new file mode 100644
index 0000000..2123a44
--- /dev/null
+++ b/tests/artifacts/Arrays/static_size.py
@@ -0,0 +1,135 @@
+import typing
+
+from algopy import Account, Array, Box, ImmutableArray, Txn, UInt64, arc4, op, subroutine, urange
+
+
+class More(arc4.Struct, frozen=True):
+    foo: arc4.UInt64
+    bar: arc4.UInt64
+
+
+class Xtra(typing.NamedTuple):
+    a: UInt64
+    b: UInt64
+    c: Account
+    d: More
+
+
+class Point(typing.NamedTuple):
+    x: arc4.UInt64
+    y: UInt64
+    other: Xtra
+
+
+class StaticSizeContract(arc4.ARC4Contract):
+    def __init__(self) -> None:
+        self.count = UInt64(0)
+
+    @arc4.abimethod()
+    def test_array(self, x1: arc4.UInt64, y1: UInt64, x2: arc4.UInt64, y2: UInt64) -> UInt64:
+        self.count = UInt64(0)
+        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()),
+        )
+        for i in urange(3):
+            assert path[i].other.b == i + 1
+            assert path[i].other.d.foo == i + 2
+            assert path[i].other.d.bar == (i + 1) * (i + 1)
+
+        Box(ImmutableArray[Point], key="a").value = path.freeze()
+        return path_length(path)
+
+    @arc4.abimethod()
+    def test_extend_from_tuple(self, some_more: tuple[More, More]) -> ImmutableArray[More]:
+        arr = Array[More]()
+        arr.extend(some_more)
+        last = arr[-1]
+        assert last == some_more[1]
+        result = arr.freeze()
+        assert result[-1] == last
+        return result
+
+    @arc4.abimethod()
+    def test_extend_from_arc4_tuple(
+        self, some_more: arc4.Tuple[More, More]
+    ) -> ImmutableArray[More]:
+        arr = Array[More]()
+        arr.extend(some_more)
+        return arr.freeze()
+
+    @arc4.abimethod()
+    def test_bool_array(self, length: UInt64) -> UInt64:
+        arr = Array[bool]()
+        assert arr.length == 0
+
+        for i in urange(1, length + 1):
+            arr.append(i % 2 == 0)
+        assert arr.length == length, "expected correct length"
+        count = UInt64(0)
+        for val in arr:
+            if val:
+                count += 1
+        return count
+
+    @arc4.abimethod()
+    def test_arc4_conversion(self, length: UInt64) -> arc4.DynamicArray[arc4.UInt64]:
+        arr = Array[arc4.UInt64]()
+        assert arr.length == 0
+
+        for i in urange(1, length + 1):
+            arr.append(arc4.UInt64(i))
+        assert arr.length == length, "expected correct length"
+        count = UInt64(0)
+        for val in arr:
+            if val:
+                count += 1
+
+        arc4_arr = arc4.DynamicArray[arc4.UInt64]()
+        arc4_arr.extend(arr)
+
+        return arc4_arr
+
+    @arc4.abimethod()
+    def sum_array(self, arc4_arr: arc4.DynamicArray[arc4.UInt64]) -> UInt64:
+        arr = Array[arc4.UInt64]()
+        arr.extend(arc4_arr)
+
+        total = UInt64(0)
+        for item in arr:
+            total += item.native
+
+        return total
+
+    @subroutine
+    def xtra(self) -> Xtra:
+        self.count += 1
+        return Xtra(
+            a=Txn.num_app_args,
+            b=self.count,
+            c=Txn.sender,
+            d=self.more(),
+        )
+
+    @subroutine(inline=False)
+    def more(self) -> More:
+        return More(foo=arc4.UInt64(self.count + 1), bar=arc4.UInt64(self.count * self.count))
+
+
+@subroutine
+def path_length(path: Array[Point]) -> UInt64:
+    last_point = path[0]
+    length = UInt64()
+    for point_idx in urange(1, path.length):
+        point = path[point_idx]
+        if point.x < last_point.x:
+            dx = last_point.x.native - point.x.native
+        else:
+            dx = point.x.native - last_point.x.native
+        if point.y < last_point.y:
+            dy = last_point.y - point.y
+        else:
+            dy = point.y - last_point.y
+        length += op.sqrt(dx * dx + dy * dy)
+    return length
diff --git a/tests/artifacts/Arrays/uint64.py b/tests/artifacts/Arrays/uint64.py
new file mode 100644
index 0000000..0e9a90d
--- /dev/null
+++ b/tests/artifacts/Arrays/uint64.py
@@ -0,0 +1,255 @@
+from algopy import Array, Txn, UInt64, arc4, op, subroutine, uenumerate, urange
+
+
+class Contract(arc4.ARC4Contract):
+    @arc4.abimethod()
+    def test_array(self) -> None:
+        arr = Array[UInt64]()
+        assert arr.length == 0
+
+        arr.append(UInt64(42))
+        assert arr.length == 1
+        assert arr[-1] == 42
+
+        add_x(arr, UInt64(5))
+        assert arr.length == 6
+        assert arr[-1] == 4
+
+        pop_x(arr, x=UInt64(3), expected=UInt64(4))
+        assert arr.length == 3
+        assert arr[-1] == 1
+
+        arr.append(UInt64(43))
+        assert arr.length == 4
+        assert arr[-1] == 43
+        assert arr[0] == 42
+
+        add_x(arr, UInt64(10))
+        assert arr.length == 14
+        assert arr[-1] == 9
+
+        arr.append(UInt64(44))
+        assert arr.length == 15
+        assert arr[-1] == 44
+
+        return_ref(arr, arr)[0] += 2
+        assert arr.length == 17
+        assert arr[0] == 44
+        assert arr[-2] == 99
+        assert arr[-1] == 100
+
+    @arc4.abimethod()
+    def test_array_extend(self) -> None:
+        arr = Array[UInt64]()
+        add_x(arr, UInt64(1))
+        arr2 = Array[UInt64]()
+        arr2.append(UInt64(1))
+        arr2.append(UInt64(2))
+        arr2.append(UInt64(3))
+
+        arr.extend(arr2)
+        assert arr.length == 4
+
+    @arc4.abimethod()
+    def test_array_multiple_append(self) -> None:
+        arr = Array[UInt64]()
+        add_x(arr, UInt64(1))
+        arr.append(UInt64(1))
+        arr.append(UInt64(2))
+        arr.append(UInt64(3))
+        assert arr.length == 4
+
+    @arc4.abimethod()
+    def overhead(self) -> None:
+        pass
+
+    @arc4.abimethod()
+    def test_array_too_long(self) -> None:
+        array = Array[UInt64]()
+        for i in urange(512):
+            array.append(i)
+        assert array.length == 512, "array is expected length"
+
+        array.append(UInt64(512))  # this will fail
+
+    @arc4.abimethod()
+    def test_array_copy_and_extend(self) -> None:
+        array = Array[UInt64]()
+        for i in urange(5):
+            array.append(i)
+        array2 = array.copy()
+
+        array.append(UInt64(5))
+        assert array.length == 6
+        assert array[-1] == 5, "expected 5"
+
+        assert array2.length == 5
+        assert array2[-1] == 4, "expected 4"
+
+        array.extend(array2)
+        assert array.length == 11
+        assert array2.length == 5
+        assert array[-1] == 4, "expected 4"
+        assert array[4] == 4, "expected 4"
+        assert array[5] == 5, "expected 4"
+        assert array[6] == 0, "expected 4"
+
+    @arc4.abimethod()
+    def test_array_evaluation_order(self) -> None:
+        arr = Array[UInt64]()
+        arr.append(UInt64(3))
+        append_length_and_return(arr).extend(append_length_and_return(arr))
+        assert arr.length == 6
+        assert arr[0] == 3
+        assert arr[1] == 1
+        assert arr[2] == 2
+        assert arr[3] == 3
+        assert arr[4] == 1
+        assert arr[5] == 2
+
+        arr[append_length_and_return(arr)[0]] = append_length_and_return(arr)[-1]
+        assert arr.length == 8
+        assert arr[6] == 6
+        assert arr[7] == 7
+        assert arr[3] == 6
+
+    @arc4.abimethod()
+    def test_allocations(self, num: UInt64) -> None:
+        for _i in urange(num):
+            alloc_test = Array[UInt64]()
+            add_x(alloc_test, UInt64(1))
+
+    @arc4.abimethod()
+    def test_iteration(self) -> None:
+        arr = Array[UInt64]()
+        for val in urange(5):
+            arr.append(val)
+        assert arr.length == 5, "expected array of length 5"
+
+        # iterate
+        last = UInt64(0)
+        for value in arr:
+            assert value >= last, "array is not sorted"
+            last = value
+
+        # enumerate
+        for idx, value in uenumerate(arr):
+            assert value == idx, "incorrect array value"
+
+        # reverse
+        for value in reversed(arr):
+            assert value <= last, "array is not sorted"
+            last = value
+
+        arc4_arr = arc4.DynamicArray[arc4.UInt64]()
+        native_arr = Array[arc4.UInt64]()
+        for i in urange(5):
+            arc4_arr.append(arc4.UInt64(i))
+            native_arr.append(arc4.UInt64(i))
+        combined_arr = arc4_arr + native_arr
+        assert combined_arr.length == 10
+        assert combined_arr[0] == 0
+        assert combined_arr[4] == 4
+        assert combined_arr[5] == 0
+        assert combined_arr[9] == 4
+
+    @arc4.abimethod()
+    def test_quicksort(self) -> None:
+        # create pseudo random array from sender address
+        rnd = Array[UInt64]()
+        for b in Txn.sender.bytes:
+            rnd.append(op.btoi(b))
+        assert rnd.length == 32, "expected array of length 32"
+
+        # sort the array
+        quicksort_window(rnd, UInt64(0), rnd.length - 1)
+
+        # array should now be in ascending order
+        last = UInt64(0)
+        for value in rnd:
+            assert value >= last, "array is not sorted"
+            last = value
+
+
+@subroutine
+def quicksort_window(arr: Array[UInt64], window_left: UInt64, window_right: UInt64) -> None:
+    left = window_left
+    right = window_right
+    pivot = arr[(window_left + window_right) // 2]
+    # partition window around pivot, so everything to the left is less
+    # and everything to the right is more or equal
+    while True:
+        # move left of window towards pivot
+        while arr[left] < pivot:
+            left += 1
+        # move right of window towards pivot
+        while pivot < arr[right]:
+            # break out of loop if right would go negative
+            if not right:
+                break
+            right -= 1
+        else:  # only runs if right is not "negative"
+            # if window isn't empty then swap values and move window in
+            if left < right:
+                arr[left], arr[right] = arr[right], arr[left]
+                left += 1
+                # break out of loop if right would go negative
+                if not right:
+                    break
+                right -= 1
+                # explicit continue to avoid hitting outer break
+                if left <= right:
+                    continue
+                # loop always ends in this scenario
+                # and an explict break consumes fewer ops
+                break
+            # if window is just one item, don't bother swapping, but still adjust window
+            if left == right:
+                left += 1
+                # don't decrement right if it would go negative
+                if right:
+                    right -= 1
+                # loop always ends in this scenario
+                # and an explict break consumes fewer ops
+                break
+        # a negative right will end up here
+        break
+
+    # sort left half of window
+    if window_left < right:
+        quicksort_window(arr, window_left, right)
+    # sort right half of window
+    if left < window_right:
+        quicksort_window(arr, left, window_right)
+
+
+@subroutine
+def return_ref(arr: Array[UInt64], arr2: Array[UInt64]) -> Array[UInt64]:
+    arr.append(UInt64(99))
+    arr2.append(UInt64(100))
+    return arr
+
+
+@subroutine
+def add_x(arr: Array[UInt64], x: UInt64) -> None:
+    for i in urange(x):
+        arr.append(i)
+
+
+@subroutine
+def pop_x(arr: Array[UInt64], x: UInt64, expected: UInt64) -> None:
+    for _i in urange(x):
+        popped = arr.pop()
+        assert popped == expected
+        expected -= 1
+
+
+@subroutine
+def append_length_and_return(arr: Array[UInt64]) -> Array[UInt64]:
+    arr.append(arr.length)
+    return arr
+
+
+@subroutine
+def do_something_with_array(arr: Array[UInt64]) -> None:
+    arr.append(UInt64(1))

From 910f166b634ee7a0b3ee4461f750ee8ace3780e1 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Fri, 14 Feb 2025 19:27:33 +0800
Subject: [PATCH 22/23] feat: support `algopy.Array` and
 `algopy.ImmutableArray` from algorand-python 2.7

---
 src/_algopy_testing/arc4.py                |  54 ++---
 src/_algopy_testing/decorators/arc4.py     |  37 +++-
 src/_algopy_testing/models/contract.py     |   4 +-
 src/_algopy_testing/primitives/__init__.py |   3 +-
 src/_algopy_testing/primitives/array.py    | 144 +++++++++++++
 src/_algopy_testing/protocols.py           |  12 ++
 src/_algopy_testing/serialize.py           | 158 ++++++++++++++
 src/_algopy_testing/state/utils.py         |   8 +-
 src/algopy/__init__.py                     |   4 +-
 tests/test_array.py                        | 228 +++++++++++++++++++++
 10 files changed, 605 insertions(+), 47 deletions(-)
 create mode 100644 src/_algopy_testing/primitives/array.py
 create mode 100644 src/_algopy_testing/serialize.py
 create mode 100644 tests/test_array.py

diff --git a/src/_algopy_testing/arc4.py b/src/_algopy_testing/arc4.py
index eb4c593..3f2ee95 100644
--- a/src/_algopy_testing/arc4.py
+++ b/src/_algopy_testing/arc4.py
@@ -745,7 +745,7 @@ def is_dynamic(self) -> bool:
         return True
 
 
-class _DynamicArrayMeta(type(_ABIEncoded), typing.Generic[_TArrayItem, _TArrayLength]):  # type: ignore  # noqa: PGH003
+class _DynamicArrayMeta(type(_ABIEncoded), typing.Generic[_TArrayItem]):  # type: ignore[misc]
     __concrete__: typing.ClassVar[dict[type, type]] = {}
 
     def __getitem__(cls, key_t: type[_TArrayItem]) -> type:
@@ -1015,17 +1015,18 @@ def __repr__(self) -> str:
 
 
 class _StructTypeInfo(_TypeInfo):
-    def __init__(self, struct_type: type[Struct]) -> None:
+    def __init__(self, struct_type: type[Struct], *, frozen: bool) -> None:
         self.struct_type = struct_type
         self.fields = dataclasses.fields(struct_type)
         self.field_names = [field.name for field in self.fields]
+        self.frozen = frozen
 
     @property
     def typ(self) -> type:
         return self.struct_type
 
     @property
-    def child_types(self) -> Iterable[_TypeInfo]:
+    def child_types(self) -> list[_TypeInfo]:
         return _tuple_type_from_struct(self.struct_type)._type_info.child_types
 
     @property
@@ -1056,8 +1057,11 @@ class Struct(MutableBytes, _ABIEncoded, metaclass=_StructMeta):  # type: ignore[
     _type_info: typing.ClassVar[_StructTypeInfo]  # type: ignore[misc]
 
     def __init_subclass__(cls, *args: typing.Any, **kwargs: dict[str, typing.Any]) -> None:
-        dataclasses.dataclass(cls, *args, **kwargs)
-        cls._type_info = _StructTypeInfo(cls)
+        # 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)
+        cls._type_info = _StructTypeInfo(cls, frozen=frozen)
 
     def __post_init__(self) -> None:
         # calling base class here to init Mutable
@@ -1073,6 +1077,10 @@ def __setattr__(self, key: str, value: typing.Any) -> None:
         super().__setattr__(key, value)
         # don't update backing value until base class has been init'd
         if hasattr(self, "_on_mutate") and key in self._type_info.field_names:
+            if self._type_info.frozen:
+                raise dataclasses.FrozenInstanceError(
+                    f"{type(self)} is frozen and cannot be modified"
+                )
             self._update_backing_value()
 
     def _update_backing_value(self) -> None:
@@ -1154,34 +1162,16 @@ def emit(event: str | Struct, /, *args: object) -> None:
     log(event_hash[:4] + event_data.value)
 
 
-def native_value_to_arc4(value: object) -> _ABIEncoded:  # noqa: PLR0911
-    import algopy
-
-    if isinstance(value, _ABIEncoded):
-        return value
-    if isinstance(value, bool):
-        return Bool(value)
-    if isinstance(value, algopy.UInt64):
-        return UInt64(value)
-    if isinstance(value, algopy.BigUInt):
-        return UInt512(value)
-    if isinstance(value, algopy.Bytes):
-        return DynamicBytes(value)
-    if isinstance(value, algopy.String):
-        return String(value)
-    if isinstance(value, tuple):
-        return Tuple(tuple(map(native_value_to_arc4, value)))
-    raise TypeError(f"Unsupported type: {type(value).__name__}")
-
-
 def _cast_arg_as_arc4(arg: object) -> _ABIEncoded:
+    from _algopy_testing.serialize import native_to_arc4
+
     if isinstance(arg, int) and not isinstance(arg, bool):
         return UInt64(arg) if arg <= MAX_UINT64 else UInt512(arg)
     if isinstance(arg, bytes):
         return DynamicBytes(arg)
     if isinstance(arg, str):
         return String(arg)
-    return native_value_to_arc4(arg)
+    return native_to_arc4(arg)
 
 
 def _find_bool(
@@ -1245,13 +1235,13 @@ def _get_max_bytes_len(type_info: _TypeInfo) -> int:
     size = 0
     if isinstance(type_info, _DynamicArrayTypeInfo):
         size += _ABI_LENGTH_SIZE
-    elif isinstance(type_info, _TupleTypeInfo | _StaticArrayTypeInfo):
+    elif isinstance(type_info, _TupleTypeInfo | _StructTypeInfo | _StaticArrayTypeInfo):
         i = 0
-        child_types = (
-            type_info.child_types
-            if isinstance(type_info, _TupleTypeInfo)
-            else [type_info.item_type] * type_info.size
-        )
+        if isinstance(type_info, _TupleTypeInfo | _StructTypeInfo):
+            child_types = type_info.child_types
+        else:
+            typing.assert_type(type_info, _StaticArrayTypeInfo)
+            child_types = [type_info.item_type] * type_info.size
         while i < len(child_types):
             if isinstance(child_types[i], _BoolTypeInfo):
                 after = _find_bool_types(child_types, i, 1)
diff --git a/src/_algopy_testing/decorators/arc4.py b/src/_algopy_testing/decorators/arc4.py
index a33b791..238cd23 100644
--- a/src/_algopy_testing/decorators/arc4.py
+++ b/src/_algopy_testing/decorators/arc4.py
@@ -79,14 +79,18 @@ def get_ordered_args(
     params = list(sig.parameters.values())[1:]  # Skip 'self'
     app_args_iter = iter(app_args)
 
-    ordered_args = [
-        (
-            kwargs.get(p.name, next(app_args_iter, p.default))
-            if p.default is not p.empty
-            else kwargs.get(p.name) or next(app_args_iter)
-        )
-        for p in params
-    ]
+    ordered_args = []
+    for p in params:
+        try:
+            arg = kwargs[p.name]
+        except KeyError:
+            try:
+                arg = next(app_args_iter)
+            except StopIteration:
+                if p.default is p.empty:
+                    raise TypeError(f"missing required argument {p.name}") from None
+                arg = p.default
+        ordered_args.append(arg)
 
     if list(app_args_iter):
         raise TypeError("Too many positional arguments")
@@ -168,6 +172,8 @@ def abimethod(  # noqa: PLR0913
 
     @functools.wraps(fn)
     def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+        from _algopy_testing.serialize import native_to_arc4
+
         contract, *app_args = args
         assert isinstance(contract, _algopy_testing.ARC4Contract), "expected ARC4 contract"
         assert fn is not None, "expected function"
@@ -186,7 +192,8 @@ 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 = _algopy_testing.arc4.native_value_to_arc4(result)
+
+                abi_result = native_to_arc4(result)
                 log(ARC4_RETURN_PREFIX, abi_result)
             return result
 
@@ -273,6 +280,8 @@ def _extract_arrays_from_args(
     app: algopy.Application,
     sender: algopy.Account,
 ) -> _TxnArrays:
+    from _algopy_testing.serialize import native_to_arc4
+
     txns = list[_algopy_testing.gtxn.TransactionBase]()
     apps = [app]
     assets = list[_algopy_testing.Asset]()
@@ -292,7 +301,7 @@ def _extract_arrays_from_args(
                 app_args.append(_algopy_testing.arc4.UInt8(len(apps)))
                 apps.append(arg_app)
             case _ as maybe_native:
-                app_args.append(_algopy_testing.arc4.native_value_to_arc4(maybe_native))
+                app_args.append(native_to_arc4(maybe_native))
     if len(app_args) > 15:
         packed = _algopy_testing.arc4.Tuple(tuple(app_args[14:]))
         app_args[14:] = [packed]
@@ -320,6 +329,7 @@ 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
 
     if annotation is None:
         return "void"
@@ -331,6 +341,13 @@ 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__", []):
+        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):
+        return f"{_type_to_arc4(annotation._element_type)}[]"
     # arc4 types
     if issubclass(annotation, _ABIEncoded):
         return annotation._type_info.arc4_name
diff --git a/src/_algopy_testing/models/contract.py b/src/_algopy_testing/models/contract.py
index 61744a8..9dc4d2c 100644
--- a/src/_algopy_testing/models/contract.py
+++ b/src/_algopy_testing/models/contract.py
@@ -9,7 +9,7 @@
 from _algopy_testing.decorators.arc4 import get_active_txn_fields, maybe_arc4_metadata
 from _algopy_testing.mutable import set_attr_on_mutate
 from _algopy_testing.primitives import Bytes, UInt64
-from _algopy_testing.protocols import BytesBacked, UInt64Backed
+from _algopy_testing.protocols import BytesBacked, Serializable, UInt64Backed
 from _algopy_testing.state.utils import deserialize, serialize
 
 if typing.TYPE_CHECKING:
@@ -165,7 +165,7 @@ def __setattr__(self, name: str, value: typing.Any) -> None:
                     state._key = name_bytes
             case _algopy_testing.BoxMap() as box_map if box_map._key_prefix is None:
                 box_map._key_prefix = name_bytes
-            case Bytes() | UInt64() | BytesBacked() | UInt64Backed() | bool():
+            case Bytes() | UInt64() | BytesBacked() | Serializable() | UInt64Backed() | bool():
                 app_id = _get_self_or_active_app_id(self)
                 lazy_context.ledger.set_global_state(app_id, name_bytes, serialize(value))
                 cls = type(self)
diff --git a/src/_algopy_testing/primitives/__init__.py b/src/_algopy_testing/primitives/__init__.py
index ee10525..274b7af 100644
--- a/src/_algopy_testing/primitives/__init__.py
+++ b/src/_algopy_testing/primitives/__init__.py
@@ -1,6 +1,7 @@
+from _algopy_testing.primitives.array import Array, ImmutableArray
 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__ = ["BigUInt", "Bytes", "String", "UInt64"]
+__all__ = ["Array", "BigUInt", "Bytes", "ImmutableArray", "String", "UInt64"]
diff --git a/src/_algopy_testing/primitives/array.py b/src/_algopy_testing/primitives/array.py
new file mode 100644
index 0000000..c08a122
--- /dev/null
+++ b/src/_algopy_testing/primitives/array.py
@@ -0,0 +1,144 @@
+import types
+import typing
+from collections.abc import Iterable, Iterator, Reversible
+
+from _algopy_testing.primitives.uint64 import UInt64
+from _algopy_testing.protocols import Serializable
+from _algopy_testing.serialize import deserialize_from_bytes, serialize_to_bytes
+
+_T = typing.TypeVar("_T")
+
+
+class _ImmutableArrayMeta(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 ImmutableArray(Serializable, typing.Generic[_T], 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:
+        from _algopy_testing.serialize import type_of
+
+        try:
+            assert cls._element_type
+        except AttributeError:
+            try:
+                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, *items: _T):
+        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)
+
+    def __iter__(self) -> Iterator[_T]:
+        return iter(self._items)
+
+    def __reversed__(self) -> Iterator[_T]:
+        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 replace(self, index: UInt64 | int, value: _T) -> "ImmutableArray[_T]":
+        copied = list(self._items)
+        copied[int(index)] = value
+        return self._from_iter(copied)
+
+    def append(self, item: _T, /) -> "ImmutableArray[_T]":
+        copied = list(self._items)
+        copied.append(item)
+        return self._from_iter(copied)
+
+    def __add__(self, other: Iterable[_T], /) -> "ImmutableArray[_T]":
+        return self._from_iter((*self._items, *other))
+
+    def pop(self) -> "ImmutableArray[_T]":
+        copied = list(self._items)
+        copied.pop()
+        return self._from_iter(copied)
+
+    def _from_iter(self, items: Iterable[_T]) -> "ImmutableArray[_T]":
+        """Returns a new array populated with items, also ensures element type info is
+        preserved."""
+        el_type = self._element_type
+        typ = ImmutableArray[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)
+
+
+class Array(Reversible[_T]):
+
+    def __init__(self, *items: _T):
+        self._items = list(items)
+
+    def __iter__(self) -> Iterator[_T]:
+        return iter(list(self._items))
+
+    def __reversed__(self) -> Iterator[_T]:
+        return reversed(self._items)
+
+    @property
+    def length(self) -> UInt64:
+        return UInt64(len(self._items))
+
+    def __getitem__(self, index: UInt64 | int) -> _T:
+        return self._items[int(index)]
+
+    def __setitem__(self, index: UInt64 | int, value: _T) -> _T:
+        self._items[int(index)] = value
+        return value
+
+    def append(self, item: _T, /) -> None:
+        self._items.append(item)
+
+    def extend(self, other: Iterable[_T], /) -> None:
+        self._items.extend(other)
+
+    def pop(self) -> _T:
+        return self._items.pop()
+
+    def copy(self) -> "Array[_T]":
+        return Array(*self._items)
+
+    def freeze(self) -> ImmutableArray[_T]:
+        return ImmutableArray(*self._items)
+
+    def __bool__(self) -> bool:
+        return bool(self._items)
diff --git a/src/_algopy_testing/protocols.py b/src/_algopy_testing/protocols.py
index 66cb5ab..adfc2ef 100644
--- a/src/_algopy_testing/protocols.py
+++ b/src/_algopy_testing/protocols.py
@@ -6,6 +6,18 @@
     import algopy
 
 
+class Serializable:
+    """For algopy testing only, allows serializing to/from bytes for types that aren't
+    BytesBacked."""
+
+    @classmethod
+    def from_bytes(cls, value: bytes, /) -> typing.Self:
+        raise NotImplementedError
+
+    def serialize(self) -> bytes:
+        raise NotImplementedError
+
+
 class BytesBacked:
     """Represents a type that is a single bytes value."""
 
diff --git a/src/_algopy_testing/serialize.py b/src/_algopy_testing/serialize.py
new file mode 100644
index 0000000..f5a337b
--- /dev/null
+++ b/src/_algopy_testing/serialize.py
@@ -0,0 +1,158 @@
+import dataclasses
+import inspect
+import typing
+from collections.abc import Callable, Sequence
+
+from _algopy_testing.primitives.uint64 import UInt64
+
+if typing.TYPE_CHECKING:
+    from _algopy_testing.arc4 import _ABIEncoded
+
+
+_T = typing.TypeVar("_T")
+_U = typing.TypeVar("_U")
+
+
+@dataclasses.dataclass(frozen=True)
+class _Serializer(typing.Generic[_T, _U]):
+    native_type: type[_T]
+    arc4_type: type[_U]
+    native_to_arc4: Callable[[_T], _U]
+    arc4_to_native: Callable[[_U], _T]
+
+
+def identity(i: _T) -> _T:
+    return i
+
+
+def get_native_to_arc4_serializer(typ: type[_T]) -> _Serializer:  # type: ignore[type-arg] # noqa: PLR0911
+    from _algopy_testing import arc4
+    from _algopy_testing.models import Account
+    from _algopy_testing.primitives import BigUInt, Bytes, ImmutableArray, String
+    from _algopy_testing.protocols import UInt64Backed
+
+    if issubclass(typ, arc4._ABIEncoded):
+        return _Serializer(
+            native_type=typ, arc4_type=typ, native_to_arc4=identity, arc4_to_native=identity
+        )
+    if issubclass(typ, bool):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.Bool,
+            native_to_arc4=arc4.Bool,
+            arc4_to_native=lambda n: n.native,
+        )
+    if issubclass(typ, UInt64Backed):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.UInt64,
+            native_to_arc4=lambda n: arc4.UInt64(n.int_),
+            arc4_to_native=lambda a: typ.from_int(a.native),
+        )
+    if issubclass(typ, BigUInt):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.UInt512,
+            native_to_arc4=arc4.UInt512,
+            arc4_to_native=lambda a: a.native,
+        )
+    if issubclass(typ, Account):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.Address,
+            native_to_arc4=arc4.Address,
+            arc4_to_native=lambda a: a.native,
+        )
+    if issubclass(typ, UInt64):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.UInt64,
+            native_to_arc4=arc4.UInt64,
+            arc4_to_native=lambda a: a.native,
+        )
+    if issubclass(typ, Bytes):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.DynamicBytes,
+            native_to_arc4=arc4.DynamicBytes,
+            arc4_to_native=lambda a: a.native,
+        )
+    if issubclass(typ, String):
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.String,
+            native_to_arc4=arc4.String,
+            arc4_to_native=lambda a: a.native,
+        )
+    if issubclass(typ, tuple) or typing.get_origin(typ) is tuple:
+        if typing.NamedTuple in getattr(typ, "__orig_bases__", []):
+            tuple_fields: Sequence[type] = list(inspect.get_annotations(typ).values())
+        else:
+            tuple_fields = typing.get_args(typ)
+        serializers = [get_native_to_arc4_serializer(i) for i in tuple_fields]
+
+        def _items_to_arc4(items: Sequence[object]) -> tuple[object, ...]:
+            result = []
+            for item, serializer in zip(items, serializers, strict=True):
+                result.append(serializer.native_to_arc4(item))
+            return tuple(result)
+
+        def _items_to_native(items: Sequence[object]) -> tuple[object, ...]:
+            result = []
+            for item, serializer in zip(items, serializers, strict=True):
+                result.append(serializer.arc4_to_native(item))
+            return tuple(result)
+
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4.Tuple[*(s.arc4_type for s in serializers)],  # type: ignore[misc]
+            native_to_arc4=lambda t: arc4.Tuple(_items_to_arc4(t)),
+            arc4_to_native=lambda t: _items_to_native(t),
+        )
+    if issubclass(typ, ImmutableArray):
+        native_element_type = typ._element_type
+        element_serializer = get_native_to_arc4_serializer(native_element_type)
+        arc4_element_type = element_serializer.arc4_type
+        arc4_type = arc4.DynamicArray[arc4_element_type]  # type: ignore[valid-type]
+        return _Serializer(
+            native_type=typ,
+            arc4_type=arc4_type,
+            native_to_arc4=lambda arr: arc4_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)),
+        )
+    raise TypeError(f"unserializable type: {typ}")
+
+
+def serialize_to_bytes(value: object) -> bytes:
+    return native_to_arc4(value).bytes.value
+
+
+def type_of(value: object) -> type:
+    """Returns the type of value, this will also ensure the type is fully parametrized
+    if it is a generic type."""
+    # get fully parametrized tuples
+    if isinstance(value, tuple) and type(value) is tuple:
+        return tuple[*(type_of(i) for i in value)]  # type: ignore[misc, no-any-return]
+    else:
+        return type(value)
+
+
+def native_to_arc4(value: object) -> "_ABIEncoded":
+    from _algopy_testing import arc4
+
+    src_type = type_of(value)
+
+    serializer = get_native_to_arc4_serializer(src_type)
+    arc4_value = serializer.native_to_arc4(value)
+    assert isinstance(arc4_value, arc4._ABIEncoded)
+    return arc4_value
+
+
+def deserialize_from_bytes(typ: type[_T], bites: bytes) -> _T:
+    serializer = get_native_to_arc4_serializer(typ)
+    arc4_value = serializer.arc4_type.from_bytes(bites)
+    native_value = serializer.arc4_to_native(arc4_value)
+    assert isinstance(native_value, typ)
+    return native_value
diff --git a/src/_algopy_testing/state/utils.py b/src/_algopy_testing/state/utils.py
index 1c37bc6..fdea1ad 100644
--- a/src/_algopy_testing/state/utils.py
+++ b/src/_algopy_testing/state/utils.py
@@ -4,7 +4,7 @@
 
 from _algopy_testing.primitives.bytes import Bytes
 from _algopy_testing.primitives.uint64 import UInt64
-from _algopy_testing.protocols import BytesBacked, UInt64Backed
+from _algopy_testing.protocols import BytesBacked, Serializable, UInt64Backed
 
 _TValue = typing.TypeVar("_TValue")
 SerializableValue = int | bytes
@@ -19,6 +19,8 @@ def serialize(value: _TValue) -> SerializableValue:
         return value.int_
     elif isinstance(value, BytesBacked):
         return value.bytes.value
+    elif isinstance(value, Serializable):
+        return value.serialize()
     else:
         raise TypeError(f"Unsupported type: {type(value)}")
 
@@ -36,6 +38,10 @@ def deserialize(typ: type[_TValue], value: SerializableValue) -> _TValue:
         if isinstance(value, int):
             raise TypeError("expected bytes, received int")
         return typ.from_bytes(Bytes(value))  # type: ignore[return-value]
+    elif issubclass(typ, Serializable):
+        if isinstance(value, int):
+            raise TypeError("expected bytes, received int")
+        return typ.from_bytes(value)  # type: ignore[return-value]
     else:
         raise TypeError(f"Unsupported type: {typ}")
 
diff --git a/src/algopy/__init__.py b/src/algopy/__init__.py
index a59165f..4c42d9a 100644
--- a/src/algopy/__init__.py
+++ b/src/algopy/__init__.py
@@ -14,7 +14,7 @@
 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 BigUInt, Bytes, String, UInt64
+from _algopy_testing.primitives import Array, BigUInt, Bytes, ImmutableArray, String, UInt64
 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
@@ -25,6 +25,7 @@
     "ARC4Contract",
     "Account",
     "Application",
+    "Array",
     "Asset",
     "BigUInt",
     "Box",
@@ -37,6 +38,7 @@
     "Contract",
     "Global",
     "GlobalState",
+    "ImmutableArray",
     "LocalState",
     "LogicSig",
     "OnCompleteAction",
diff --git a/tests/test_array.py b/tests/test_array.py
new file mode 100644
index 0000000..fb7dc0b
--- /dev/null
+++ b/tests/test_array.py
@@ -0,0 +1,228 @@
+import typing
+
+import algosdk
+import pytest
+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.static_size import More, StaticSizeContract
+from tests.artifacts.Arrays.uint64 import Contract as UInt64Contract
+
+
+@pytest.fixture()
+def context() -> typing.Generator[AlgopyTestContext, None, None]:
+    with algopy_testing_context() as ctx:
+        yield ctx
+
+
+# tests are based on puyapy compiler tests for array
+def test_array_uint64(context: AlgopyTestContext) -> None:  # noqa: ARG001
+    contract = UInt64Contract()
+
+    contract.test_array()
+    contract.test_array_extend()
+    contract.test_array_multiple_append()
+    contract.test_iteration()
+    contract.test_array_copy_and_extend()
+    contract.test_array_evaluation_order()
+
+    contract.test_allocations(UInt64(255))
+    contract.test_array_too_long()
+
+    contract.test_quicksort()
+
+
+def test_array_static_size(context: AlgopyTestContext) -> None:
+    contract = StaticSizeContract()
+
+    x1, y1 = 3, 4
+    x2, y2 = 6, 8
+    sender = context.default_sender.public_key
+    assert (
+        contract.test_array(arc4.UInt64(x1), arc4.UInt64(y1), arc4.UInt64(x2), arc4.UInt64(y2))
+        == 15
+    )
+
+    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)))[]",
+        [
+            (0, 0, (5, 1, sender, (2, 1))),
+            (x1, y1, (5, 2, sender, (3, 4))),
+            (x2, y2, (5, 3, sender, (4, 9))),
+        ],
+    )
+
+    arr_1_to_5 = arc4.DynamicArray(*(arc4.UInt64(i + 1) for i in range(5)))
+    assert contract.test_arc4_conversion(UInt64(5)) == arr_1_to_5
+    assert contract.sum_array(arr_1_to_5) == 15
+
+    assert contract.test_bool_array(UInt64(5)) == 2
+    assert contract.test_bool_array(UInt64(4)) == 2
+    assert contract.test_bool_array(UInt64(6)) == 3
+
+    more_a = More(arc4.UInt64(1), arc4.UInt64(2))
+    more_b = More(arc4.UInt64(3), arc4.UInt64(4))
+    response = contract.test_extend_from_tuple((more_a, more_b))
+    assert list(response) == [
+        More(arc4.UInt64(1), arc4.UInt64(2)),
+        More(arc4.UInt64(3), arc4.UInt64(4)),
+    ]
+
+    response = contract.test_extend_from_arc4_tuple(arc4.Tuple((more_a, more_b)))
+    assert list(response) == [
+        More(arc4.UInt64(1), arc4.UInt64(2)),
+        More(arc4.UInt64(3), arc4.UInt64(4)),
+    ]
+
+
+def test_immutable_array(context: AlgopyTestContext) -> None:
+    app = ImmutableArrayContract()
+
+    app.test_uint64_array()
+    assert context.ledger.get_global_state(app, b"a") == _get_arc4_bytes(
+        "uint64[]", [42, 0, 23, 2, *range(10), 44]
+    )
+
+    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)]
+    )
+
+    app.test_fixed_size_named_tuple_array()
+    assert context.ledger.get_global_state(app, b"d") == _get_arc4_bytes(
+        "(uint64,bool,bool)[]", [(i, i % 2 == 0, i * 3 % 2 == 0) for i in range(5)]
+    )
+
+    app.test_dynamic_sized_tuple_array()
+    assert context.ledger.get_global_state(app, b"e") == _get_arc4_bytes(
+        "(uint64,byte[])[]", [(i + 1, b"\x00" * i) for i in range(4)]
+    )
+
+    app.test_dynamic_sized_named_tuple_array()
+    assert context.ledger.get_global_state(app, b"f") == _get_arc4_bytes(
+        "(uint64,string)[]", [(i + 1, " " * i) for i in range(4)]
+    )
+
+    app.test_bit_packed_tuples()
+    assert context.ledger.get_global_state(app, b"bool2") == _get_arc4_bytes(
+        "(bool,bool)[]", [(i == 0, i == 1) for i in range(5)]
+    )
+    assert context.ledger.get_global_state(app, b"bool7") == _get_arc4_bytes(
+        "(uint64,bool,bool,bool,bool,bool,bool,bool,uint64)[]",
+        [(i, i == 0, i == 1, i == 2, i == 3, i == 4, i == 5, i == 6, i + 1) for i in range(5)],
+    )
+    assert context.ledger.get_global_state(app, b"bool8") == _get_arc4_bytes(
+        "(uint64,bool,bool,bool,bool,bool,bool,bool,bool,uint64)[]",
+        [
+            (i, i == 0, i == 1, i == 2, i == 3, i == 4, i == 5, i == 6, i == 7, i + 1)
+            for i in range(5)
+        ],
+    )
+    assert context.ledger.get_global_state(app, b"bool9") == _get_arc4_bytes(
+        "(uint64,bool,bool,bool,bool,bool,bool,bool,bool,bool,uint64)[]",
+        [
+            (i, i == 0, i == 1, i == 2, i == 3, i == 4, i == 5, i == 6, i == 7, i == 8, i + 1)
+            for i in range(5)
+        ],
+    )
+
+    append = 5
+    arr = [MyTuple(UInt64(i), i % 2 == 0, i % 3 == 0) for i in range(append)]
+    response = app.test_convert_to_array_and_back(arr=ImmutableArray(*arr), append=UInt64(append))
+    assert list(response) == [*arr, *arr]
+
+    response = app.test_concat_with_arc4_tuple(arc4.Tuple((arc4.UInt64(3), arc4.UInt64(4))))
+    assert list(response) == list(map(arc4.UInt64, [1, 2, 3, 4]))
+
+    response = app.test_concat_with_native_tuple((arc4.UInt64(3), arc4.UInt64(4)))
+    assert list(response) == list(map(arc4.UInt64, [1, 2, 3, 4]))
+
+    one = MyDynamicSizedTuple(UInt64(1), String("one"))
+    two = MyDynamicSizedTuple(UInt64(2), String("foo"))
+    three = MyDynamicSizedTuple(UInt64(3), String("tree"))
+    four = MyDynamicSizedTuple(UInt64(4), String("floor"))
+    response = app.test_concat_immutable_dynamic(
+        ImmutableArray(one, two), ImmutableArray(three, four)
+    )
+    assert list(response) == [one, two, three, four]
+
+
+_EXPECTED_LENGTH_20 = [False, False, True, *(False,) * 17]
+
+
+@pytest.mark.parametrize("length", [0, 1, 2, 3, 4, 7, 8, 9, 15, 16, 17])
+def test_immutable_bool_array(context: AlgopyTestContext, length: int) -> None:
+    app = ImmutableArrayContract()
+
+    app.test_bool_array(UInt64(length))
+    expected = _EXPECTED_LENGTH_20[:length]
+    assert context.ledger.get_global_state(app, b"g") == _get_arc4_bytes("bool[]", expected)
+
+
+def test_immutable_routing(context: AlgopyTestContext) -> None:  # noqa: ARG001
+    app = ImmutableArrayContract()
+
+    response = app.sum_uints_and_lengths_and_trues(
+        arr1=ImmutableArray(*map(UInt64, range(5))),
+        arr2=ImmutableArray(*[i % 2 == 0 for i in range(6)]),
+        arr3=ImmutableArray(*[MyTuple(UInt64(i), i % 2 == 0, i % 3 == 0) for i in range(7)]),
+        arr4=ImmutableArray(*[MyDynamicSizedTuple(UInt64(i), String(" " * i)) for i in range(8)]),
+    )
+    assert response == tuple(map(UInt64, (10, 3, 21 + 4 + 3, 28 * 2)))
+
+    append = 4
+    response = app.test_uint64_return(UInt64(append))
+    assert list(response) == list(map(UInt64, [1, 2, 3, *range(append)]))
+
+    append = 5
+    response = app.test_bool_return(UInt64(append))
+    assert list(response) == [
+        *[True, False, True, False, True],
+        *(i % 2 == 0 for i in range(append)),
+    ]
+
+    append = 6
+    response = app.test_tuple_return(UInt64(append))
+    assert list(response) == [
+        MyTuple(UInt64(0), True, False),
+        *(MyTuple(UInt64(i), i % 2 == 0, i % 3 == 0) for i in range(append)),
+    ]
+
+    append = 3
+    response = app.test_dynamic_tuple_return(UInt64(append))
+    assert list(response) == [
+        MyDynamicSizedTuple(UInt64(0), String("Hello")),
+        *(MyDynamicSizedTuple(UInt64(i), String(" " * i)) for i in range(append)),
+    ]
+
+
+def test_nested_immutable(context: AlgopyTestContext) -> None:  # noqa: ARG001
+    app = ImmutableArrayContract()
+
+    response = app.test_nested_array(
+        arr_to_add=UInt64(5),
+        arr=ImmutableArray(
+            *(ImmutableArray(*(UInt64(i * j) for i in range(5))) for j in range(3))
+        ),
+    )
+    assert list(response) == list(
+        map(
+            UInt64,
+            (
+                0,
+                10,
+                20,
+                0,
+                0,
+                1,
+                3,
+                6,
+            ),
+        )
+    )
+
+
+def _get_arc4_bytes(arc4_type: str, value: object) -> bytes:
+    return algosdk.abi.ABIType.from_string(arc4_type).encode(value)

From fa507ff4d1cd4dd651b053a24c730b5276ebf632 Mon Sep 17 00:00:00 2001
From: Daniel McGregor <daniel.mcgregor@makerx.com.au>
Date: Tue, 18 Feb 2025 19:03:30 +0800
Subject: [PATCH 23/23] docs: fix doctest example for `algopy.EllipticCurve`

---
 docs/testing-guide/opcodes.md | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/docs/testing-guide/opcodes.md b/docs/testing-guide/opcodes.md
index 29d5eca..76bf77c 100644
--- a/docs/testing-guide/opcodes.md
+++ b/docs/testing-guide/opcodes.md
@@ -353,20 +353,22 @@ test_mock_vrf_verify()
 from unittest.mock import patch, MagicMock
 import algopy
 
-def test_mock_elliptic_curve_decompress():
-    mock_result = (algopy.Bytes(b'x_coord'), algopy.Bytes(b'y_coord'))
-    with patch('algopy.op.EllipticCurve.decompress', return_value=mock_result) as mock_decompress:
-        result = algopy.op.EllipticCurve.decompress(
+def test_mock_elliptic_curve_add():
+    mock_result = algopy.Bytes(b'result')
+    with patch('algopy.op.EllipticCurve.add', return_value=mock_result) as mock_add:
+        result = algopy.op.EllipticCurve.add(
             algopy.op.EC.BN254g1,
-            algopy.Bytes(b'compressed_point')
+            algopy.Bytes(b'a'),
+            algopy.Bytes(b'b')
         )
     assert result == mock_result
-    mock_decompress.assert_called_once_with(
+    mock_add.assert_called_once_with(
         algopy.op.EC.BN254g1,
-        algopy.Bytes(b'compressed_point')
+        algopy.Bytes(b'a'),
+        algopy.Bytes(b'b'),
     )
 
-test_mock_elliptic_curve_decompress()
+test_mock_elliptic_curve_add()
 ```
 
 These examples demonstrate how to mock key mockable opcodes in `algorand-python-testing`. Use similar techniques (in your preferred testing framework) for other mockable opcodes like `algopy.compile_logicsig`, `algopy.arc4.arc4_create`, and `algopy.arc4.arc4_update`.