diff --git a/examples/htlc-logicsig/signature.algo.ts b/examples/htlc-logicsig/signature.algo.ts new file mode 100644 index 0000000..df6cf1f --- /dev/null +++ b/examples/htlc-logicsig/signature.algo.ts @@ -0,0 +1,39 @@ +import { Account, Bytes, Global, LogicSig, op, TransactionType, Txn, Uint64, uint64 } from '@algorandfoundation/algorand-typescript' +import algosdk from 'algosdk' + +export default class HashedTimeLockedLogicSig extends LogicSig { + program(): boolean | uint64 { + // Participants + const sellerAddress = Bytes(algosdk.decodeAddress('6ZHGHH5Z5CTPCF5WCESXMGRSVK7QJETR63M3NY5FJCUYDHO57VTCMJOBGY').publicKey) + const buyerAddress = Bytes(algosdk.decodeAddress('7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M').publicKey) + const seller = Account(sellerAddress) + const buyer = Account(buyerAddress) + + // Contract parameters + const feeLimit = Uint64(1000) + const secretHash = Bytes.fromHex('2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b') + const timeout = Uint64(3000) + + // Transaction conditions + const isPayment = Txn.typeEnum === TransactionType.Payment + const isFeeAcceptable = Txn.fee < feeLimit + const isNoCloseTo = Txn.closeRemainderTo === Global.zeroAddress + const isNoRekey = Txn.rekeyTo === Global.zeroAddress + + // Safety conditions + const safetyConditions = isPayment && isNoCloseTo && isNoRekey + + // Seller receives payment if correct secret is provided + const isToSeller = Txn.receiver === seller + const isSecretCorrect = op.sha256(op.arg(0)) === secretHash + const sellerReceives = isToSeller && isSecretCorrect + + // Buyer receives refund after timeout + const isToBuyer = Txn.receiver === buyer + const isAfterTimeout = Txn.firstValid > timeout + const buyerReceivesRefund = isToBuyer && isAfterTimeout + + // Final contract logic + return isFeeAcceptable && safetyConditions && (sellerReceives || buyerReceivesRefund) + } +} diff --git a/examples/htlc-logicsig/signature.spec.ts b/examples/htlc-logicsig/signature.spec.ts new file mode 100644 index 0000000..2224f10 --- /dev/null +++ b/examples/htlc-logicsig/signature.spec.ts @@ -0,0 +1,32 @@ +import { Account, Bytes } from '@algorandfoundation/algorand-typescript' +import { TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing' +import algosdk from 'algosdk' +import { afterEach, describe, expect, it } from 'vitest' +import { ZERO_ADDRESS } from '../../src/constants' +import HashedTimeLockedLogicSig from './signature.algo' + +describe('HTLC LogicSig', () => { + const ctx = new TestExecutionContext() + + afterEach(() => { + ctx.reset() + }) + + it('seller receives payment if correct secret is provided', () => { + const receiverAddress = Bytes(algosdk.decodeAddress('6ZHGHH5Z5CTPCF5WCESXMGRSVK7QJETR63M3NY5FJCUYDHO57VTCMJOBGY').publicKey) + ctx.txn + .createScope([ + ctx.any.txn.payment({ + fee: 500, + firstValid: 1000, + closeRemainderTo: Account(ZERO_ADDRESS), + rekeyTo: Account(ZERO_ADDRESS), + receiver: Account(receiverAddress), + }), + ]) + .execute(() => { + const result = ctx.executeLogicSig(new HashedTimeLockedLogicSig(), Bytes('secret')) + expect(result).toBe(true) + }) + }) +}) diff --git a/examples/rollup.config.ts b/examples/rollup.config.ts index bc04ab8..79ef1aa 100644 --- a/examples/rollup.config.ts +++ b/examples/rollup.config.ts @@ -12,6 +12,7 @@ const config: RollupOptions = { 'examples/auction/contract.algo.ts', 'examples/voting/contract.algo.ts', 'examples/simple-voting/contract.algo.ts', + 'examples/zk-whitelist/contract.algo.ts', ], output: [ { diff --git a/examples/zk-whitelist/contract.algo.ts b/examples/zk-whitelist/contract.algo.ts new file mode 100644 index 0000000..d1a9224 --- /dev/null +++ b/examples/zk-whitelist/contract.algo.ts @@ -0,0 +1,94 @@ +import { + abimethod, + Account, + arc4, + assert, + BigUint, + Bytes, + ensureBudget, + Global, + itxn, + LocalState, + op, + OpUpFeeSource, + TemplateVar, + Txn, + uint64, +} from '@algorandfoundation/algorand-typescript' + +const curveMod = 21888242871839275222246405745257275088548364400416034343698204186575808495617n +const verifierBudget = 145000 + +export default class ZkWhitelistContract extends arc4.Contract { + appName: arc4.Str | undefined + whiteList = LocalState() + + @abimethod({ onCreate: 'require' }) + create(name: arc4.Str) { + // Create the application + this.appName = name + } + + @abimethod({ allowActions: ['UpdateApplication', 'DeleteApplication'] }) + update() { + // Update the application if it is mutable (manager only) + assert(Global.creatorAddress === Txn.sender) + } + + @abimethod({ allowActions: ['OptIn', 'CloseOut'] }) + optInOrOut() { + // Opt in or out of the application + return + } + + @abimethod() + addAddressToWhitelist(address: arc4.Address, proof: arc4.DynamicArray): arc4.Str { + /* + Add caller to the whitelist if the zk proof is valid. + On success, will return an empty string. Otherwise, will return an error + message. + */ + ensureBudget(verifierBudget, OpUpFeeSource.GroupCredit) + // The verifier expects public inputs to be in the curve field, but an + // Algorand address might represent a number larger than the field + // modulus, so to be safe we take the address modulo the field modulus + const addressMod = arc4.interpretAsArc4(op.bzero(32).bitwiseOr(Bytes(BigUint(address.bytes) % curveMod))) + // Verify the proof by calling the deposit verifier app + const verified = this.verifyProof(TemplateVar('VERIFIER_APP_ID'), proof, new arc4.DynamicArray(addressMod)) + if (!verified.native) { + return new arc4.Str('Proof verification failed') + } + // if successful, add the sender to the whitelist by setting local state + const account = Account(address.bytes) + if (Txn.sender !== account) { + return new arc4.Str('Sender address does not match authorized address') + } + this.whiteList(account).value = true + return new arc4.Str('') + } + + @abimethod() + isOnWhitelist(address: arc4.Address): arc4.Bool { + // Check if an address is on the whitelist + const account = address.native + const optedIn = op.appOptedIn(account, Global.currentApplicationId) + if (!optedIn) { + return new arc4.Bool(false) + } + const whitelisted = this.whiteList(account).value + return new arc4.Bool(whitelisted) + } + + verifyProof(appId: uint64, proof: arc4.DynamicArray, publicInputs: arc4.DynamicArray): arc4.Bool { + // Verify a proof using the verifier app. + const verified = itxn + .applicationCall({ + appId: appId, + fee: 0, + appArgs: [arc4.methodSelector('verify(byte[32][],byte[32][])bool'), proof.copy(), publicInputs.copy()], + onCompletion: arc4.OnCompleteAction.NoOp, + }) + .submit().lastLog + return arc4.interpretAsArc4(verified, 'log') + } +} diff --git a/examples/zk-whitelist/contract.spec.ts b/examples/zk-whitelist/contract.spec.ts new file mode 100644 index 0000000..468e93b --- /dev/null +++ b/examples/zk-whitelist/contract.spec.ts @@ -0,0 +1,79 @@ +import { arc4, Bytes } from '@algorandfoundation/algorand-typescript' +import { TestExecutionContext } from '@algorandfoundation/algorand-typescript-testing' +import { afterEach, describe, expect, it } from 'vitest' +import { ABI_RETURN_VALUE_LOG_PREFIX } from '../../src/constants' +import ZkWhitelistContract from './contract.algo' + +describe('ZK Whitelist', () => { + const ctx = new TestExecutionContext() + + afterEach(() => { + ctx.reset() + }) + + it('should be able to add address to whitelist', () => { + // Arrange + const contract = ctx.contract.create(ZkWhitelistContract) + contract.create(ctx.any.arc4.str(10)) + + const address = new arc4.Address(ctx.defaultSender) + const proof = new arc4.DynamicArray(new arc4.Address(Bytes(new Uint8Array(Array(32).fill(0))))) + + const dummyVerifierApp = ctx.any.application({ appLogs: [ABI_RETURN_VALUE_LOG_PREFIX.concat(Bytes.fromHex('80'))] }) + ctx.setTemplateVar('VERIFIER_APP_ID', dummyVerifierApp.id) + + // Act + const result = contract.addAddressToWhitelist(address, proof) + + // Assert + expect(result.native).toEqual('') + expect(contract.whiteList(ctx.defaultSender).value).toEqual(true) + }) + + it('returns error message if proof verification fails', () => { + // Arrange + const contract = ctx.contract.create(ZkWhitelistContract) + contract.create(ctx.any.arc4.str(10)) + + const address = ctx.any.arc4.address() + const proof = new arc4.DynamicArray(new arc4.Address(Bytes(new Uint8Array(Array(32).fill(0))))) + const dummyVerifierApp = ctx.any.application({ appLogs: [ABI_RETURN_VALUE_LOG_PREFIX.concat(Bytes(''))] }) + ctx.setTemplateVar('VERIFIER_APP_ID', dummyVerifierApp.id) + + // Act + const result = contract.addAddressToWhitelist(address, proof) + + // Assert + expect(result.native).toEqual('Proof verification failed') + }) + + it('returns true if address is already in whitelist', () => { + // Arrange + const contract = ctx.contract.create(ZkWhitelistContract) + contract.create(ctx.any.arc4.str(10)) + + const dummyAccount = ctx.any.account({ optedApplications: [ctx.ledger.getApplicationForContract(contract)] }) + contract.whiteList(dummyAccount).value = true + + // Act + const result = contract.isOnWhitelist(new arc4.Address(dummyAccount)) + + // Assert + expect(result.native).toBe(true) + }) + + it('returns false if address is not in whitelist', () => { + // Arrange + const contract = ctx.contract.create(ZkWhitelistContract) + contract.create(ctx.any.arc4.str(10)) + + const dummyAccount = ctx.any.account({ optedApplications: [ctx.ledger.getApplicationForContract(contract)] }) + contract.whiteList(dummyAccount).value = false + + // Act + const result = contract.isOnWhitelist(new arc4.Address(dummyAccount)) + + // Assert + expect(result.native).toBe(false) + }) +}) diff --git a/package-lock.json b/package-lock.json index b96dcaf..8235042 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,8 +9,8 @@ "version": "1.0.0", "hasInstallScript": true, "dependencies": { - "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.22", - "@algorandfoundation/puya-ts": "^1.0.0-alpha.34", + "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.23", + "@algorandfoundation/puya-ts": "^1.0.0-alpha.35", "elliptic": "^6.5.7", "js-sha256": "^0.11.0", "js-sha3": "^0.9.3", @@ -73,9 +73,9 @@ } }, "node_modules/@algorandfoundation/algorand-typescript": { - "version": "0.0.1-alpha.22", - "resolved": "https://registry.npmjs.org/@algorandfoundation/algorand-typescript/-/algorand-typescript-0.0.1-alpha.22.tgz", - "integrity": "sha512-RhPxX2wU3srIEmA8EgjEbE8lJQqJrUW78aKS2VnpVS/uejHMDDt+kQIjtjpNEB+vxli8shaBYZ8TM0h1wE5b0g==", + "version": "0.0.1-alpha.23", + "resolved": "https://registry.npmjs.org/@algorandfoundation/algorand-typescript/-/algorand-typescript-0.0.1-alpha.23.tgz", + "integrity": "sha512-hK1rom4MD2qn3tO03Bsui8lcuA7WF5CeFGdUCIrRJgc+wLnWKNx0s9TkAotrl8VwfD5Wg7Gn3u9txz4RgdQsPw==", "peerDependencies": { "tslib": "^2.6.2" } @@ -13262,6 +13262,7 @@ "version": "5.7.2", "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz", "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==", + "dev": true, "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", diff --git a/package.json b/package.json index 513f04a..0e2b138 100644 --- a/package.json +++ b/package.json @@ -63,8 +63,8 @@ "tslib": "^2.6.2" }, "dependencies": { - "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.22", - "@algorandfoundation/puya-ts": "^1.0.0-alpha.34", + "@algorandfoundation/algorand-typescript": "^0.0.1-alpha.23", + "@algorandfoundation/puya-ts": "^1.0.0-alpha.35", "elliptic": "^6.5.7", "js-sha256": "^0.11.0", "js-sha3": "^0.9.3", diff --git a/src/constants.ts b/src/constants.ts index 2637b14..b218a66 100644 --- a/src/constants.ts +++ b/src/constants.ts @@ -3,7 +3,11 @@ import { Bytes } from '@algorandfoundation/algorand-typescript' export const UINT64_SIZE = 64 export const UINT512_SIZE = 512 export const MAX_UINT8 = 2 ** 8 - 1 +export const MAX_UINT16 = 2 ** 16 - 1 +export const MAX_UINT32 = 2 ** 32 - 1 export const MAX_UINT64 = 2n ** 64n - 1n +export const MAX_UINT128 = 2n ** 128n - 1n +export const MAX_UINT256 = 2n ** 256n - 1n export const MAX_UINT512 = 2n ** 512n - 1n export const MAX_BYTES_SIZE = 4096 export const MAX_LOG_SIZE = 1024 @@ -43,6 +47,7 @@ export const ABI_RETURN_VALUE_LOG_PREFIX = Bytes.fromHex('151F7C75') export const UINT64_OVERFLOW_UNDERFLOW_MESSAGE = 'Uint64 overflow or underflow' export const BIGUINT_OVERFLOW_UNDERFLOW_MESSAGE = 'BigUint overflow or underflow' +export const DEFAULT_TEMPLATE_VAR_PREFIX = 'TMPL_' export const APP_ID_PREFIX = 'appID' export const HASH_BYTES_LENGTH = 32 diff --git a/src/impl/acct-params.ts b/src/impl/acct-params.ts index 2864405..9042446 100644 --- a/src/impl/acct-params.ts +++ b/src/impl/acct-params.ts @@ -1,6 +1,7 @@ -import { Account, gtxn, internal, uint64 } from '@algorandfoundation/algorand-typescript' +import { Account, Application, gtxn, internal, uint64 } from '@algorandfoundation/algorand-typescript' import { lazyContext } from '../context-helpers/internal-context' import { asMaybeUint64Cls } from '../util' +import { getApp } from './app-params' export const getAccount = (acct: Account | internal.primitives.StubUint64Compat): Account => { const acctId = asMaybeUint64Cls(acct) @@ -21,6 +22,19 @@ export const minBalance = (a: Account | internal.primitives.StubUint64Compat): u return acct.minBalance } +export const appOptedIn = ( + a: Account | internal.primitives.StubUint64Compat, + b: Application | internal.primitives.StubUint64Compat, +): boolean => { + const account = getAccount(a) + const app = getApp(b) + + if (account === undefined || app === undefined) { + return false + } + return account.isOptedIn(app) +} + export const AcctParams: internal.opTypes.AcctParamsType = { acctBalance(a: Account | internal.primitives.StubUint64Compat): readonly [uint64, boolean] { const acct = getAccount(a) diff --git a/src/impl/ensure-budget.ts b/src/impl/ensure-budget.ts new file mode 100644 index 0000000..3ebb307 --- /dev/null +++ b/src/impl/ensure-budget.ts @@ -0,0 +1,5 @@ +import { OpUpFeeSource, uint64 } from '@algorandfoundation/algorand-typescript' + +export function ensureBudgetImpl(_budget: uint64, _feeSource: OpUpFeeSource = OpUpFeeSource.GroupCredit) { + // ensureBudget function is emulated to be a no-op +} diff --git a/src/impl/index.ts b/src/impl/index.ts index 159e731..42bd62b 100644 --- a/src/impl/index.ts +++ b/src/impl/index.ts @@ -1,15 +1,16 @@ -export { AcctParams, balance, minBalance } from './acct-params' +export { AcctParams, appOptedIn, balance, minBalance } from './acct-params' export { AppGlobal } from './app-global' export { AppLocal } from './app-local' export { AppParams } from './app-params' export { AssetHolding } from './asset-holding' export { AssetParams } from './asset-params' +export { Block } from './block' export { Box } from './box' export * from './crypto' export { Global } from './global' export { GTxn } from './gtxn' export { GITxn, ITxn, ITxnCreate } from './itxn' +export { arg } from './logicSigArg' export * from './pure' -export { Scratch, gloadBytes, gloadUint64 } from './scratch' -export { Block } from './block' -export { Txn, gaid } from './txn' +export { gloadBytes, gloadUint64, Scratch } from './scratch' +export { gaid, Txn } from './txn' diff --git a/src/impl/logicSigArg.ts b/src/impl/logicSigArg.ts new file mode 100644 index 0000000..6d411fc --- /dev/null +++ b/src/impl/logicSigArg.ts @@ -0,0 +1,8 @@ +import { bytes, internal } from '@algorandfoundation/algorand-typescript' +import { lazyContext } from '../context-helpers/internal-context' +import { asNumber } from '../util' + +export const arg = (a: internal.primitives.StubUint64Compat): bytes => { + const index = asNumber(a) + return lazyContext.value.activeLogicSigArgs[index] +} diff --git a/src/impl/pure.ts b/src/impl/pure.ts index 6d655f7..c81a94b 100644 --- a/src/impl/pure.ts +++ b/src/impl/pure.ts @@ -1,7 +1,7 @@ import { Base64, biguint, Bytes, bytes, internal, Uint64, uint64 } from '@algorandfoundation/algorand-typescript' import { BITS_IN_BYTE, MAX_BYTES_SIZE, MAX_UINT64, MAX_UINT8, UINT64_SIZE } from '../constants' import { notImplementedError, testInvariant } from '../errors' -import { asBigUint, asBytes, asMaybeBytesCls, asMaybeUint64Cls, asUint64Cls, binaryStringToBytes } from '../util' +import { asBigUint, asBytes, asBytesCls, asMaybeBytesCls, asMaybeUint64Cls, asUint64Cls, binaryStringToBytes } from '../util' export const addw = (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat): readonly [uint64, uint64] => { const uint64A = internal.primitives.Uint64Cls.fromCompat(a) @@ -172,6 +172,10 @@ export const itob = (a: internal.primitives.StubUint64Compat): bytes => { return asUint64Cls(a).toBytes().asAlgoTs() } +export const len = (a: internal.primitives.StubBytesCompat): uint64 => { + return asBytesCls(a).length.asAlgoTs() +} + export const mulw = (a: internal.primitives.StubUint64Compat, b: internal.primitives.StubUint64Compat): readonly [uint64, uint64] => { const uint64A = internal.primitives.Uint64Cls.fromCompat(a) const uint64B = internal.primitives.Uint64Cls.fromCompat(b) diff --git a/src/impl/template-var.ts b/src/impl/template-var.ts new file mode 100644 index 0000000..e49cfc4 --- /dev/null +++ b/src/impl/template-var.ts @@ -0,0 +1,11 @@ +import { internal } from '@algorandfoundation/algorand-typescript' +import { DEFAULT_TEMPLATE_VAR_PREFIX } from '../constants' +import { lazyContext } from '../context-helpers/internal-context' + +export function TemplateVarImpl(variableName: string, prefix = DEFAULT_TEMPLATE_VAR_PREFIX): T { + const key = prefix + variableName + if (!Object.hasOwn(lazyContext.value.templateVars, key)) { + throw internal.errors.codeError(`Template variable ${key} not found in test context!`) + } + return lazyContext.value.templateVars[prefix + variableName] as T +} diff --git a/src/runtime-helpers.ts b/src/runtime-helpers.ts index 5671a7e..48b08d6 100644 --- a/src/runtime-helpers.ts +++ b/src/runtime-helpers.ts @@ -2,11 +2,14 @@ import { internal } from '@algorandfoundation/algorand-typescript' import { ARC4Encoded } from '@algorandfoundation/algorand-typescript/arc4' import { MAX_UINT64 } from './constants' import type { TypeInfo } from './encoders' +import { AccountCls } from './impl/account' import { DeliberateAny } from './typescript-helpers' import { nameOfType } from './util' export { attachAbiMetadata } from './abi-metadata' export * from './impl/encoded-types' +export { ensureBudgetImpl } from './impl/ensure-budget' +export { TemplateVarImpl } from './impl/template-var' export function switchableValue(x: unknown): bigint | string | boolean { if (typeof x === 'boolean') return x @@ -37,6 +40,9 @@ export function binaryOp(left: unknown, right: unknown, op: BinaryOps) { if (left instanceof ARC4Encoded && right instanceof ARC4Encoded) { return arc4EncodedOp(left, right, op) } + if (left instanceof AccountCls && right instanceof AccountCls) { + return accountBinaryOp(left, right, op) + } if (left instanceof internal.primitives.BigUintCls || right instanceof internal.primitives.BigUintCls) { return bigUintBinaryOp(left, right, op) } @@ -84,6 +90,16 @@ function arc4EncodedOp(left: ARC4Encoded, right: ARC4Encoded, op: BinaryOps): De internal.errors.internalError(`Unsupported operator ${op}`) } } + +function accountBinaryOp(left: AccountCls, right: AccountCls, op: BinaryOps): DeliberateAny { + switch (op) { + case '===': + case '!==': + return bytesBinaryOp(left.bytes, right.bytes, op) + default: + internal.errors.internalError(`Unsupported operator ${op}`) + } +} function uint64BinaryOp(left: DeliberateAny, right: DeliberateAny, op: BinaryOps): DeliberateAny { const lbi = internal.primitives.Uint64Cls.fromCompat(left).valueOf() const rbi = internal.primitives.Uint64Cls.fromCompat(right).valueOf() diff --git a/src/test-execution-context.ts b/src/test-execution-context.ts index f86e183..efbf68e 100644 --- a/src/test-execution-context.ts +++ b/src/test-execution-context.ts @@ -1,5 +1,6 @@ -import { Account, Application, Asset, bytes, internal, uint64 } from '@algorandfoundation/algorand-typescript' +import { Account, Application, Asset, bytes, internal, LogicSig, uint64 } from '@algorandfoundation/algorand-typescript' import { captureMethodConfig } from './abi-metadata' +import { DEFAULT_TEMPLATE_VAR_PREFIX } from './constants' import { DecodedLogs, LogDecoding } from './decode-logs' import * as ops from './impl' import { AccountCls } from './impl/account' @@ -18,6 +19,7 @@ import { Box, BoxMap, BoxRef, GlobalState, LocalState } from './impl/state' import { ContractContext } from './subcontexts/contract-context' import { LedgerContext } from './subcontexts/ledger-context' import { TransactionContext } from './subcontexts/transaction-context' +import { DeliberateAny } from './typescript-helpers' import { getRandomBytes } from './util' import { ValueGenerator } from './value-generators' @@ -27,6 +29,8 @@ export class TestExecutionContext implements internal.ExecutionContext { #txnContext: TransactionContext #valueGenerator: ValueGenerator #defaultSender: Account + #activeLogicSigArgs: bytes[] + #template_vars: Record = {} constructor(defaultSenderAddress?: bytes) { internal.ctxMgr.instance = this @@ -35,6 +39,7 @@ export class TestExecutionContext implements internal.ExecutionContext { this.#txnContext = new TransactionContext() this.#valueGenerator = new ValueGenerator() this.#defaultSender = Account(defaultSenderAddress ?? getRandomBytes(32).asAlgoTs()) + this.#activeLogicSigArgs = [] } account(address?: bytes): Account { @@ -120,10 +125,33 @@ export class TestExecutionContext implements internal.ExecutionContext { } } + get activeLogicSigArgs(): bytes[] { + return this.#activeLogicSigArgs + } + + get templateVars(): Record { + return this.#template_vars + } + + executeLogicSig(logicSig: LogicSig, ...args: bytes[]): boolean | uint64 { + this.#activeLogicSigArgs = args + try { + return logicSig.program() + } finally { + this.#activeLogicSigArgs = [] + } + } + + setTemplateVar(name: string, value: DeliberateAny) { + this.#template_vars[DEFAULT_TEMPLATE_VAR_PREFIX + name] = value + } + reset() { this.#contractContext = new ContractContext() this.#ledgerContext = new LedgerContext() this.#txnContext = new TransactionContext() + this.#activeLogicSigArgs = [] + this.#template_vars = {} internal.ctxMgr.reset() internal.ctxMgr.instance = this } diff --git a/src/test-transformer/node-factory.ts b/src/test-transformer/node-factory.ts index 49d5607..684c734 100644 --- a/src/test-transformer/node-factory.ts +++ b/src/test-transformer/node-factory.ts @@ -94,12 +94,11 @@ export const nodeFactory = { ) }, - callARC4EncodingUtil(node: ts.CallExpression, typeInfo?: TypeInfo) { - const identifierExpression = node.expression as ts.Identifier + callStubbedFunction(functionName: string, node: ts.CallExpression, typeInfo?: TypeInfo) { const infoString = JSON.stringify(typeInfo) const updatedPropertyAccessExpression = factory.createPropertyAccessExpression( factory.createIdentifier('runtimeHelpers'), - `${identifierExpression.getText()}Impl`, + `${functionName}Impl`, ) return factory.createCallExpression( diff --git a/src/test-transformer/visitors.ts b/src/test-transformer/visitors.ts index 76e5edf..8275563 100644 --- a/src/test-transformer/visitors.ts +++ b/src/test-transformer/visitors.ts @@ -1,4 +1,5 @@ import { ptypes, SourceLocation, TypeResolver } from '@algorandfoundation/puya-ts' +import path from 'path' import ts from 'typescript' import type { TypeInfo } from '../encoders' import { instanceOfAny } from '../typescript-helpers' @@ -12,10 +13,16 @@ import { const { factory } = ts +const algotsModulePaths = [ + `@algorandfoundation${path.sep}algorand-typescript`, + `${path.sep}puya-ts${path.sep}packages${path.sep}algo-ts${path.sep}`, +] + type VisitorHelper = { additionalStatements: ts.Statement[] resolveType(node: ts.Node): ptypes.PType sourceLocation(node: ts.Node): SourceLocation + tryGetSymbol(node: ts.Node): ts.Symbol | undefined } export class SourceFileVisitor { @@ -26,8 +33,8 @@ export class SourceFileVisitor { program: ts.Program, private config: TransformerConfig, ) { - const typeResolver = new TypeResolver(program.getTypeChecker(), program.getCurrentDirectory()) - + const typeChecker = program.getTypeChecker() + const typeResolver = new TypeResolver(typeChecker, program.getCurrentDirectory()) this.helper = { additionalStatements: [], resolveType(node: ts.Node): ptypes.PType { @@ -37,6 +44,10 @@ export class SourceFileVisitor { return ptypes.anyPType } }, + tryGetSymbol(node: ts.Node): ts.Symbol | undefined { + const s = typeChecker.getSymbolAtLocation(node) + return s && s.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(s) : s + }, sourceLocation(node: ts.Node): SourceLocation { return SourceLocation.fromNode(node, program.getCurrentDirectory()) }, @@ -45,7 +56,6 @@ export class SourceFileVisitor { public result(): ts.SourceFile { const updatedSourceFile = ts.visitNode(this.sourceFile, this.visit) as ts.SourceFile - return factory.updateSourceFile(updatedSourceFile, [ nodeFactory.importHelpers(this.config.testingPackageName), ...updatedSourceFile.statements, @@ -91,20 +101,21 @@ class ExpressionVisitor { const isGeneric = isGenericType(type) const isArc4Encoded = isArc4EncodedType(type) - if (isGeneric || isArc4Encoded) { - let updatedNode = node - const info = getGenericTypeInfo(type) + const info = isGeneric || isArc4Encoded ? getGenericTypeInfo(type) : undefined + let updatedNode = node + + if (ts.isNewExpression(updatedNode)) { if (isArc4EncodedType(type)) { - if (ts.isNewExpression(updatedNode)) { - updatedNode = nodeFactory.instantiateARC4EncodedType(updatedNode, info) - } else if (ts.isCallExpression(updatedNode) && isCallingARC4EncodingUtils(updatedNode)) { - updatedNode = nodeFactory.callARC4EncodingUtil(updatedNode, info) - } + updatedNode = nodeFactory.instantiateARC4EncodedType(updatedNode, info) } - return isGeneric - ? nodeFactory.captureGenericTypeInfo(ts.visitEachChild(updatedNode, this.visit, this.context), JSON.stringify(info)) - : ts.visitEachChild(updatedNode, this.visit, this.context) } + if (ts.isCallExpression(updatedNode)) { + const stubbedFunctionName = tryGetStubbedFunctionName(updatedNode, this.helper) + updatedNode = stubbedFunctionName ? nodeFactory.callStubbedFunction(stubbedFunctionName, updatedNode, info) : updatedNode + } + return isGeneric + ? nodeFactory.captureGenericTypeInfo(ts.visitEachChild(updatedNode, this.visit, this.context), JSON.stringify(info)) + : ts.visitEachChild(updatedNode, this.visit, this.context) } return ts.visitEachChild(node, this.visit, this.context) } @@ -194,7 +205,7 @@ class FunctionOrMethodVisitor { if (ts.isNewExpression(node)) { return new ExpressionVisitor(this.context, this.helper, node).result() } - if (ts.isCallExpression(node) && isCallingARC4EncodingUtils(node)) { + if (ts.isCallExpression(node) && tryGetStubbedFunctionName(node, this.helper)) { return new ExpressionVisitor(this.context, this.helper, node).result() } @@ -331,9 +342,17 @@ const getGenericTypeInfo = (type: ptypes.PType): TypeInfo => { return result } -const isCallingARC4EncodingUtils = (node: ts.CallExpression) => { - if (node.expression.kind !== ts.SyntaxKind.Identifier) return false - const identityExpression = node.expression as ts.Identifier - const utilMethods = ['interpretAsArc4', 'decodeArc4', 'encodeArc4'] - return utilMethods.includes(identityExpression.text) +const tryGetStubbedFunctionName = (node: ts.CallExpression, helper: VisitorHelper): string | undefined => { + if (node.expression.kind !== ts.SyntaxKind.Identifier && !ts.isPropertyAccessExpression(node.expression)) return undefined + const identityExpression = ts.isPropertyAccessExpression(node.expression) + ? (node.expression as ts.PropertyAccessExpression).name + : (node.expression as ts.Identifier) + const functionSymbol = helper.tryGetSymbol(identityExpression) + if (functionSymbol) { + const sourceFileName = functionSymbol.valueDeclaration?.getSourceFile().fileName + if (sourceFileName && !algotsModulePaths.some((s) => sourceFileName.includes(s))) return undefined + } + const functionName = functionSymbol?.getName() ?? identityExpression.text + const stubbedFunctionNames = ['interpretAsArc4', 'decodeArc4', 'encodeArc4', 'TemplateVar', 'ensureBudget'] + return stubbedFunctionNames.includes(functionName) ? functionName : undefined } diff --git a/src/value-generators/arc4.ts b/src/value-generators/arc4.ts new file mode 100644 index 0000000..e9df2ad --- /dev/null +++ b/src/value-generators/arc4.ts @@ -0,0 +1,114 @@ +import { arc4 } from '@algorandfoundation/algorand-typescript' +import { BITS_IN_BYTE, MAX_UINT128, MAX_UINT16, MAX_UINT256, MAX_UINT32, MAX_UINT512, MAX_UINT64, MAX_UINT8 } from '../constants' +import { AddressImpl, DynamicBytesImpl, StrImpl, UintNImpl } from '../impl/encoded-types' +import { getRandomBigInt, getRandomBytes, getRandomNumber } from '../util' +import { AvmValueGenerator } from './avm' + +export class Arc4ValueGenerator { + /** + * Generate a random Algorand address. + * @returns: A new, random Algorand address. + * */ + address(): arc4.Address { + const source = new AvmValueGenerator().account() + const result = new AddressImpl({ name: 'StaticArray', genericArgs: { elementType: { name: 'Byte' }, size: { name: '32' } } }, source) + return result + } + + /** + * Generate a random UintN8 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT8. + * @returns: A random UintN8 value. + * */ + uintN8(minValue = 0, maxValue = MAX_UINT8): arc4.UintN8 { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '8' }] }, getRandomNumber(minValue, maxValue)) + } + + /** + * Generate a random UintN16 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT16. + * @returns: A random UintN16 value. + * */ + uintN16(minValue = 0, maxValue = MAX_UINT16): arc4.UintN16 { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '16' }] }, getRandomNumber(minValue, maxValue)) + } + + /** + * Generate a random UintN32 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT32. + * @returns: A random UintN32 value. + * */ + uintN32(minValue = 0, maxValue = MAX_UINT32): arc4.UintN32 { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '32' }] }, getRandomNumber(minValue, maxValue)) + } + + /** + * Generate a random UintN64 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT64. + * @returns: A random UintN64 value. + * */ + uintN64(minValue = 0, maxValue = MAX_UINT64): arc4.UintN64 { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '64' }] }, getRandomBigInt(minValue, maxValue)) + } + + /** + * Generate a random UintN128 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT128. + * @returns: A random UintN128 value. + * */ + uintN128(minValue = 0, maxValue = MAX_UINT128): arc4.UintN128 { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '128' }] }, getRandomBigInt(minValue, maxValue)) + } + + /** + * Generate a random UintN256 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT256. + * @returns: A random UintN256 value. + * */ + uintN256(minValue = 0, maxValue = MAX_UINT256): arc4.UintN256 { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '256' }] }, getRandomBigInt(minValue, maxValue)) + } + + /** + * Generate a random UintN512 within the specified range. + * @param minValue: Minimum value (inclusive). Defaults to 0. + * @param maxValue: Maximum value (inclusive). Defaults to MAX_UINT512. + * @returns: A random UintN512 value. + * */ + uintN512(minValue = 0, maxValue = MAX_UINT512): arc4.UintN<512> { + return new UintNImpl({ name: 'UintN', genericArgs: [{ name: '512' }] }, getRandomBigInt(minValue, maxValue)) + } + + /** + * Generate a random dynamic bytes of size `n` bits. + * @param n: The number of bits for the dynamic bytes. Must be a multiple of 8, otherwise + * the last byte will be truncated. + * @returns: A new, random dynamic bytes of size `n` bits. + * */ + dynamicBytes(n: number): arc4.DynamicBytes { + return new DynamicBytesImpl( + { name: 'DynamicArray', genericArgs: { elementType: { name: 'Byte' } } }, + getRandomBytes(n / BITS_IN_BYTE).asAlgoTs(), + ) + } + + /** + * Generate a random dynamic string of size `n` bits. + * @param n: The number of bits for the string. + * @returns: A new, random string of size `n` bits. + * */ + str(n: number): arc4.Str { + // Calculate the number of characters needed (rounding up) + const numChars = n + 7 // 8 + + // Generate random string + const bytes = getRandomBytes(numChars) + return new StrImpl(JSON.stringify(undefined), bytes.toString()) + } +} diff --git a/src/value-generators/index.ts b/src/value-generators/index.ts index ad3fe82..f077945 100644 --- a/src/value-generators/index.ts +++ b/src/value-generators/index.ts @@ -1,11 +1,14 @@ +import { Arc4ValueGenerator } from './arc4' import { AvmValueGenerator } from './avm' import { TxnValueGenerator } from './txn' export class ValueGenerator extends AvmValueGenerator { txn: TxnValueGenerator + arc4: Arc4ValueGenerator constructor() { super() this.txn = new TxnValueGenerator() + this.arc4 = new Arc4ValueGenerator() } } diff --git a/tests/artifacts/miscellaneous-ops/contract.algo.ts b/tests/artifacts/miscellaneous-ops/contract.algo.ts index 0caefed..9876d85 100644 --- a/tests/artifacts/miscellaneous-ops/contract.algo.ts +++ b/tests/artifacts/miscellaneous-ops/contract.algo.ts @@ -144,6 +144,13 @@ export class MiscellaneousOpsContract extends arc4.Contract { return result } + @arc4.abimethod() + public verify_bytes_len(a: bytes, pad_a_size: uint64): uint64 { + const paddedA = op.bzero(pad_a_size).concat(a) + const result = op.len(paddedA) + return result + } + @arc4.abimethod() public verify_mulw(a: uint64, b: uint64): readonly [uint64, uint64] { const result = op.mulw(a, b) diff --git a/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.approval.teal b/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.approval.teal index 2fb67ab..a53da57 100644 --- a/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.approval.teal +++ b/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.approval.teal @@ -13,10 +13,10 @@ __puya_arc4_router__: // export class MiscellaneousOpsContract extends arc4.Contract { proto 0 1 txn NumAppArgs - bz __puya_arc4_router___bare_routing@38 - 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 // 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[]" + bz __puya_arc4_router___bare_routing@39 + pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xc58d30e0 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a // 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_bytes_len(byte[],uint64)uint64", 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[]" txna ApplicationArgs 0 - match __puya_arc4_router___verify_addw_route@2 __puya_arc4_router___verify_base64_decode_standard_route@3 __puya_arc4_router___verify_base64_decode_url_route@4 __puya_arc4_router___verify_bytes_bitlen_route@5 __puya_arc4_router___verify_uint64_bitlen_route@6 __puya_arc4_router___verify_bsqrt_route@7 __puya_arc4_router___verify_btoi_route@8 __puya_arc4_router___verify_bzero_route@9 __puya_arc4_router___verify_concat_route@10 __puya_arc4_router___verify_divmodw_route@11 __puya_arc4_router___verify_divw_route@12 __puya_arc4_router___verify_err_route@13 __puya_arc4_router___verify_exp_route@14 __puya_arc4_router___verify_expw_route@15 __puya_arc4_router___verify_extract_route@16 __puya_arc4_router___verify_extract_from_2_route@17 __puya_arc4_router___verify_extract_uint16_route@18 __puya_arc4_router___verify_extract_uint32_route@19 __puya_arc4_router___verify_extract_uint64_route@20 __puya_arc4_router___verify_getbit_bytes_route@21 __puya_arc4_router___verify_getbit_uint64_route@22 __puya_arc4_router___verify_getbyte_route@23 __puya_arc4_router___verify_itob_route@24 __puya_arc4_router___verify_mulw_route@25 __puya_arc4_router___verify_replace_route@26 __puya_arc4_router___verify_select_bytes_route@27 __puya_arc4_router___verify_select_uint64_route@28 __puya_arc4_router___verify_setbit_bytes_route@29 __puya_arc4_router___verify_setbit_uint64_route@30 __puya_arc4_router___verify_setbyte_route@31 __puya_arc4_router___verify_shl_route@32 __puya_arc4_router___verify_shr_route@33 __puya_arc4_router___verify_sqrt_route@34 __puya_arc4_router___verify_substring_route@35 + match __puya_arc4_router___verify_addw_route@2 __puya_arc4_router___verify_base64_decode_standard_route@3 __puya_arc4_router___verify_base64_decode_url_route@4 __puya_arc4_router___verify_bytes_bitlen_route@5 __puya_arc4_router___verify_uint64_bitlen_route@6 __puya_arc4_router___verify_bsqrt_route@7 __puya_arc4_router___verify_btoi_route@8 __puya_arc4_router___verify_bzero_route@9 __puya_arc4_router___verify_concat_route@10 __puya_arc4_router___verify_divmodw_route@11 __puya_arc4_router___verify_divw_route@12 __puya_arc4_router___verify_err_route@13 __puya_arc4_router___verify_exp_route@14 __puya_arc4_router___verify_expw_route@15 __puya_arc4_router___verify_extract_route@16 __puya_arc4_router___verify_extract_from_2_route@17 __puya_arc4_router___verify_extract_uint16_route@18 __puya_arc4_router___verify_extract_uint32_route@19 __puya_arc4_router___verify_extract_uint64_route@20 __puya_arc4_router___verify_getbit_bytes_route@21 __puya_arc4_router___verify_getbit_uint64_route@22 __puya_arc4_router___verify_getbyte_route@23 __puya_arc4_router___verify_itob_route@24 __puya_arc4_router___verify_bytes_len_route@25 __puya_arc4_router___verify_mulw_route@26 __puya_arc4_router___verify_replace_route@27 __puya_arc4_router___verify_select_bytes_route@28 __puya_arc4_router___verify_select_uint64_route@29 __puya_arc4_router___verify_setbit_bytes_route@30 __puya_arc4_router___verify_setbit_uint64_route@31 __puya_arc4_router___verify_setbyte_route@32 __puya_arc4_router___verify_shl_route@33 __puya_arc4_router___verify_shr_route@34 __puya_arc4_router___verify_sqrt_route@35 __puya_arc4_router___verify_substring_route@36 intc_1 // 0 retsub @@ -25,9 +25,9 @@ __puya_arc4_router___verify_addw_route@2: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -54,9 +54,9 @@ __puya_arc4_router___verify_base64_decode_standard_route@3: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -82,9 +82,9 @@ __puya_arc4_router___verify_base64_decode_url_route@4: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -110,9 +110,9 @@ __puya_arc4_router___verify_bytes_bitlen_route@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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -135,9 +135,9 @@ __puya_arc4_router___verify_uint64_bitlen_route@6: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -158,9 +158,9 @@ __puya_arc4_router___verify_bsqrt_route@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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -186,9 +186,9 @@ __puya_arc4_router___verify_btoi_route@8: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -209,9 +209,9 @@ __puya_arc4_router___verify_bzero_route@9: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -237,9 +237,9 @@ __puya_arc4_router___verify_concat_route@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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -271,9 +271,9 @@ __puya_arc4_router___verify_divmodw_route@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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -314,9 +314,9 @@ __puya_arc4_router___verify_divw_route@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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -341,9 +341,9 @@ __puya_arc4_router___verify_err_route@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 callsub verify_err intc_0 // 1 retsub @@ -353,9 +353,9 @@ __puya_arc4_router___verify_exp_route@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 // tests/artifacts/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -378,9 +378,9 @@ __puya_arc4_router___verify_expw_route@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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -407,9 +407,9 @@ __puya_arc4_router___verify_extract_route@16: // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -435,18 +435,18 @@ __puya_arc4_router___verify_extract_route@16: retsub __puya_arc4_router___verify_extract_from_2_route@17: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:98 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:99 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 extract 2 0 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:98 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:99 // @arc4.abimethod() callsub verify_extract_from_2 dup @@ -463,20 +463,20 @@ __puya_arc4_router___verify_extract_from_2_route@17: retsub __puya_arc4_router___verify_extract_uint16_route@18: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:104 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:105 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 extract 2 0 txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:104 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:105 // @arc4.abimethod() callsub verify_extract_uint16 itob @@ -488,20 +488,20 @@ __puya_arc4_router___verify_extract_uint16_route@18: retsub __puya_arc4_router___verify_extract_uint32_route@19: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:110 + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 extract 2 0 txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:110 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:111 // @arc4.abimethod() callsub verify_extract_uint32 itob @@ -513,20 +513,20 @@ __puya_arc4_router___verify_extract_uint32_route@19: retsub __puya_arc4_router___verify_extract_uint64_route@20: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:116 + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 extract 2 0 txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:116 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:117 // @arc4.abimethod() callsub verify_extract_uint64 itob @@ -538,20 +538,20 @@ __puya_arc4_router___verify_extract_uint64_route@20: retsub __puya_arc4_router___verify_getbit_bytes_route@21: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:122 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:123 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 extract 2 0 txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:122 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:123 // @arc4.abimethod() callsub verify_getbit_bytes itob @@ -563,20 +563,20 @@ __puya_arc4_router___verify_getbit_bytes_route@21: retsub __puya_arc4_router___verify_getbit_uint64_route@22: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:128 + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 btoi txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:128 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:129 // @arc4.abimethod() callsub verify_getbit_uint64 itob @@ -588,20 +588,20 @@ __puya_arc4_router___verify_getbit_uint64_route@22: retsub __puya_arc4_router___verify_getbyte_route@23: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:134 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:135 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 extract 2 0 txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:134 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:135 // @arc4.abimethod() callsub verify_getbyte itob @@ -613,18 +613,18 @@ __puya_arc4_router___verify_getbyte_route@23: retsub __puya_arc4_router___verify_itob_route@24: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:140 + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:140 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:141 // @arc4.abimethod() callsub verify_itob dup @@ -640,21 +640,46 @@ __puya_arc4_router___verify_itob_route@24: intc_0 // 1 retsub -__puya_arc4_router___verify_mulw_route@25: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:146 +__puya_arc4_router___verify_bytes_len_route@25: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:147 // @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/miscellaneous-ops/contract.algo.ts:3 + // export class MiscellaneousOpsContract extends arc4.Contract { + txna ApplicationArgs 1 + extract 2 0 + txna ApplicationArgs 2 + btoi + // tests/artifacts/miscellaneous-ops/contract.algo.ts:147 + // @arc4.abimethod() + callsub verify_bytes_len + itob + bytec_0 // 0x151f7c75 + swap + concat + log + intc_0 // 1 + retsub + +__puya_arc4_router___verify_mulw_route@26: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:154 + // @arc4.abimethod() + txn OnCompletion + ! + assert // OnCompletion is not NoOp + txn ApplicationID + assert // can only call when not creating // tests/artifacts/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 btoi txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:146 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:154 // @arc4.abimethod() callsub verify_mulw swap @@ -669,14 +694,14 @@ __puya_arc4_router___verify_mulw_route@25: intc_0 // 1 retsub -__puya_arc4_router___verify_replace_route@26: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:152 +__puya_arc4_router___verify_replace_route@27: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:160 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -685,7 +710,7 @@ __puya_arc4_router___verify_replace_route@26: btoi txna ApplicationArgs 3 extract 2 0 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:152 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:160 // @arc4.abimethod() callsub verify_replace dup @@ -701,14 +726,14 @@ __puya_arc4_router___verify_replace_route@26: intc_0 // 1 retsub -__puya_arc4_router___verify_select_bytes_route@27: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:158 +__puya_arc4_router___verify_select_bytes_route@28: + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -717,7 +742,7 @@ __puya_arc4_router___verify_select_bytes_route@27: extract 2 0 txna ApplicationArgs 3 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:158 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:166 // @arc4.abimethod() callsub verify_select_bytes dup @@ -733,14 +758,14 @@ __puya_arc4_router___verify_select_bytes_route@27: intc_0 // 1 retsub -__puya_arc4_router___verify_select_uint64_route@28: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:164 +__puya_arc4_router___verify_select_uint64_route@29: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:172 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -749,7 +774,7 @@ __puya_arc4_router___verify_select_uint64_route@28: btoi txna ApplicationArgs 3 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:164 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:172 // @arc4.abimethod() callsub verify_select_uint64 itob @@ -760,14 +785,14 @@ __puya_arc4_router___verify_select_uint64_route@28: intc_0 // 1 retsub -__puya_arc4_router___verify_setbit_bytes_route@29: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:170 +__puya_arc4_router___verify_setbit_bytes_route@30: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:178 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -776,7 +801,7 @@ __puya_arc4_router___verify_setbit_bytes_route@29: btoi txna ApplicationArgs 3 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:170 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:178 // @arc4.abimethod() callsub verify_setbit_bytes dup @@ -792,14 +817,14 @@ __puya_arc4_router___verify_setbit_bytes_route@29: intc_0 // 1 retsub -__puya_arc4_router___verify_setbit_uint64_route@30: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:176 +__puya_arc4_router___verify_setbit_uint64_route@31: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:184 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -808,7 +833,7 @@ __puya_arc4_router___verify_setbit_uint64_route@30: btoi txna ApplicationArgs 3 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:176 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:184 // @arc4.abimethod() callsub verify_setbit_uint64 itob @@ -819,14 +844,14 @@ __puya_arc4_router___verify_setbit_uint64_route@30: intc_0 // 1 retsub -__puya_arc4_router___verify_setbyte_route@31: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:182 +__puya_arc4_router___verify_setbyte_route@32: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:190 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -835,7 +860,7 @@ __puya_arc4_router___verify_setbyte_route@31: btoi txna ApplicationArgs 3 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:182 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:190 // @arc4.abimethod() callsub verify_setbyte dup @@ -851,21 +876,21 @@ __puya_arc4_router___verify_setbyte_route@31: intc_0 // 1 retsub -__puya_arc4_router___verify_shl_route@32: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:188 +__puya_arc4_router___verify_shl_route@33: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:196 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 btoi txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:188 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:196 // @arc4.abimethod() callsub verify_shl itob @@ -876,21 +901,21 @@ __puya_arc4_router___verify_shl_route@32: intc_0 // 1 retsub -__puya_arc4_router___verify_shr_route@33: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:194 +__puya_arc4_router___verify_shr_route@34: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:202 // @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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 btoi txna ApplicationArgs 2 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:194 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:202 // @arc4.abimethod() callsub verify_shr itob @@ -901,19 +926,19 @@ __puya_arc4_router___verify_shr_route@33: intc_0 // 1 retsub -__puya_arc4_router___verify_sqrt_route@34: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:200 +__puya_arc4_router___verify_sqrt_route@35: + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:200 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:208 // @arc4.abimethod() callsub verify_sqrt itob @@ -924,14 +949,14 @@ __puya_arc4_router___verify_sqrt_route@34: intc_0 // 1 retsub -__puya_arc4_router___verify_substring_route@35: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:206 +__puya_arc4_router___verify_substring_route@36: + // tests/artifacts/miscellaneous-ops/contract.algo.ts: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/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txna ApplicationArgs 1 @@ -940,7 +965,7 @@ __puya_arc4_router___verify_substring_route@35: btoi txna ApplicationArgs 3 btoi - // tests/artifacts/miscellaneous-ops/contract.algo.ts:206 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:214 // @arc4.abimethod() callsub verify_substring dup @@ -956,18 +981,18 @@ __puya_arc4_router___verify_substring_route@35: intc_0 // 1 retsub -__puya_arc4_router___bare_routing@38: +__puya_arc4_router___bare_routing@39: // tests/artifacts/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { txn OnCompletion - bnz __puya_arc4_router___after_if_else@42 + bnz __puya_arc4_router___after_if_else@43 txn ApplicationID ! - assert // is creating + assert // can only call when creating intc_0 // 1 retsub -__puya_arc4_router___after_if_else@42: +__puya_arc4_router___after_if_else@43: // tests/artifacts/miscellaneous-ops/contract.algo.ts:3 // export class MiscellaneousOpsContract extends arc4.Contract { intc_1 // 0 @@ -1227,307 +1252,327 @@ verify_extract: // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes: verify_extract_from_2: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:98-99 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:99-100 // @arc4.abimethod() // public verify_extract_from_2(a: bytes): bytes { proto 1 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:100 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:101 // const result = op.extract(a, 2, 0) frame_dig -1 extract 2 0 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:101 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:102 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64: verify_extract_uint16: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:104-105 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:105-106 // @arc4.abimethod() // public verify_extract_uint16(a: bytes, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:106 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:107 // const result = op.extractUint16(a, b) frame_dig -2 frame_dig -1 extract_uint16 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:107 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:108 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64: verify_extract_uint32: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:110-111 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:111-112 // @arc4.abimethod() // public verify_extract_uint32(a: bytes, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:112 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:113 // const result = op.extractUint32(a, b) frame_dig -2 frame_dig -1 extract_uint32 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:113 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:114 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64: verify_extract_uint64: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:116-117 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:117-118 // @arc4.abimethod() // public verify_extract_uint64(a: bytes, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:118 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:119 // const result = op.extractUint64(a, b) frame_dig -2 frame_dig -1 extract_uint64 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:119 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:120 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64: verify_getbit_bytes: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:122-123 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:123-124 // @arc4.abimethod() // public verify_getbit_bytes(a: bytes, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:124 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:125 // const result = op.getBit(a, b) frame_dig -2 frame_dig -1 getbit - // tests/artifacts/miscellaneous-ops/contract.algo.ts:125 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:126 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64: verify_getbit_uint64: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:128-129 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:129-130 // @arc4.abimethod() // public verify_getbit_uint64(a: uint64, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:130 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:131 // const result = op.getBit(a, b) frame_dig -2 frame_dig -1 getbit - // tests/artifacts/miscellaneous-ops/contract.algo.ts:131 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:132 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64: verify_getbyte: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:134-135 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:135-136 // @arc4.abimethod() // public verify_getbyte(a: bytes, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:136 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:137 // const result = op.getByte(a, b) frame_dig -2 frame_dig -1 getbyte - // tests/artifacts/miscellaneous-ops/contract.algo.ts:137 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:138 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes: verify_itob: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:140-141 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:141-142 // @arc4.abimethod() // public verify_itob(a: uint64): bytes { proto 1 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:142 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:143 // const result = op.itob(a) frame_dig -1 itob - // tests/artifacts/miscellaneous-ops/contract.algo.ts:143 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:144 + // return result + retsub + + +// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bytes_len(a: bytes, pad_a_size: uint64) -> uint64: +verify_bytes_len: + // tests/artifacts/miscellaneous-ops/contract.algo.ts:147-148 + // @arc4.abimethod() + // public verify_bytes_len(a: bytes, pad_a_size: uint64): uint64 { + proto 2 1 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:149 + // const paddedA = op.bzero(pad_a_size).concat(a) + frame_dig -1 + bzero + frame_dig -2 + concat + // tests/artifacts/miscellaneous-ops/contract.algo.ts:150 + // const result = op.len(paddedA) + len + // tests/artifacts/miscellaneous-ops/contract.algo.ts:151 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64: verify_mulw: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:146-147 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:154-155 // @arc4.abimethod() // public verify_mulw(a: uint64, b: uint64): readonly [uint64, uint64] { proto 2 2 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:148 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:156 // const result = op.mulw(a, b) frame_dig -2 frame_dig -1 mulw - // tests/artifacts/miscellaneous-ops/contract.algo.ts:149 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:157 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes: verify_replace: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:152-153 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:160-161 // @arc4.abimethod() // public verify_replace(a: bytes, b: uint64, c: bytes): bytes { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:154 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:162 // const result = op.replace(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 replace3 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:155 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:163 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes: verify_select_bytes: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:158-159 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:166-167 // @arc4.abimethod() // public verify_select_bytes(a: bytes, b: bytes, c: uint64): bytes { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:160 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:168 // const result = op.select(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 select - // tests/artifacts/miscellaneous-ops/contract.algo.ts:161 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:169 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64: verify_select_uint64: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:164-165 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:172-173 // @arc4.abimethod() // public verify_select_uint64(a: uint64, b: uint64, c: uint64): uint64 { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:166 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:174 // const result = op.select(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 select - // tests/artifacts/miscellaneous-ops/contract.algo.ts:167 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:175 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes: verify_setbit_bytes: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:170-171 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:178-179 // @arc4.abimethod() // public verify_setbit_bytes(a: bytes, b: uint64, c: uint64): bytes { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:172 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:180 // const result = op.setBit(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 setbit - // tests/artifacts/miscellaneous-ops/contract.algo.ts:173 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:181 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64: verify_setbit_uint64: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:176-177 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:184-185 // @arc4.abimethod() // public verify_setbit_uint64(a: uint64, b: uint64, c: uint64): uint64 { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:178 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:186 // const result = op.setBit(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 setbit - // tests/artifacts/miscellaneous-ops/contract.algo.ts:179 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:187 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes: verify_setbyte: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:182-183 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:190-191 // @arc4.abimethod() // public verify_setbyte(a: bytes, b: uint64, c: uint64): bytes { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:184 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:192 // const result = op.setByte(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 setbyte - // tests/artifacts/miscellaneous-ops/contract.algo.ts:185 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:193 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64: verify_shl: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:188-189 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:196-197 // @arc4.abimethod() // public verify_shl(a: uint64, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:190 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:198 // const result = op.shl(a, b) frame_dig -2 frame_dig -1 shl - // tests/artifacts/miscellaneous-ops/contract.algo.ts:191 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:199 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64: verify_shr: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:194-195 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:202-203 // @arc4.abimethod() // public verify_shr(a: uint64, b: uint64): uint64 { proto 2 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:196 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:204 // const result = op.shr(a, b) frame_dig -2 frame_dig -1 shr - // tests/artifacts/miscellaneous-ops/contract.algo.ts:197 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:205 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64: verify_sqrt: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:200-201 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:208-209 // @arc4.abimethod() // public verify_sqrt(a: uint64): uint64 { proto 1 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:202 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:210 // const result = op.sqrt(a) frame_dig -1 sqrt - // tests/artifacts/miscellaneous-ops/contract.algo.ts:203 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:211 // return result retsub // tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes: verify_substring: - // tests/artifacts/miscellaneous-ops/contract.algo.ts:206-207 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:214-215 // @arc4.abimethod() // public verify_substring(a: bytes, b: uint64, c: uint64): bytes { proto 3 1 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:208 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:216 // const result = op.substring(a, b, c) frame_dig -3 frame_dig -2 frame_dig -1 substring3 - // tests/artifacts/miscellaneous-ops/contract.algo.ts:209 + // tests/artifacts/miscellaneous-ops/contract.algo.ts:217 // return result retsub diff --git a/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc32.json b/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc32.json index 3825523..ad99366 100644 --- a/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc32.json +++ b/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc32.json @@ -115,6 +115,11 @@ "no_op": "CALL" } }, + "verify_bytes_len(byte[],uint64)uint64": { + "call_config": { + "no_op": "CALL" + } + }, "verify_mulw(uint64,uint64)(uint64,uint64)": { "call_config": { "no_op": "CALL" @@ -172,7 +177,7 @@ } }, "source": { - "approval": "#pragma version 10

tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.approvalProgram:
    intcblock 1 0
    bytecblock 0x151f7c75
    callsub __puya_arc4_router__
    return


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.__puya_arc4_router__() -> uint64:
__puya_arc4_router__:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    proto 0 1
    txn NumAppArgs
    bz __puya_arc4_router___bare_routing@38
    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 // 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[]"
    txna ApplicationArgs 0
    match __puya_arc4_router___verify_addw_route@2 __puya_arc4_router___verify_base64_decode_standard_route@3 __puya_arc4_router___verify_base64_decode_url_route@4 __puya_arc4_router___verify_bytes_bitlen_route@5 __puya_arc4_router___verify_uint64_bitlen_route@6 __puya_arc4_router___verify_bsqrt_route@7 __puya_arc4_router___verify_btoi_route@8 __puya_arc4_router___verify_bzero_route@9 __puya_arc4_router___verify_concat_route@10 __puya_arc4_router___verify_divmodw_route@11 __puya_arc4_router___verify_divw_route@12 __puya_arc4_router___verify_err_route@13 __puya_arc4_router___verify_exp_route@14 __puya_arc4_router___verify_expw_route@15 __puya_arc4_router___verify_extract_route@16 __puya_arc4_router___verify_extract_from_2_route@17 __puya_arc4_router___verify_extract_uint16_route@18 __puya_arc4_router___verify_extract_uint32_route@19 __puya_arc4_router___verify_extract_uint64_route@20 __puya_arc4_router___verify_getbit_bytes_route@21 __puya_arc4_router___verify_getbit_uint64_route@22 __puya_arc4_router___verify_getbyte_route@23 __puya_arc4_router___verify_itob_route@24 __puya_arc4_router___verify_mulw_route@25 __puya_arc4_router___verify_replace_route@26 __puya_arc4_router___verify_select_bytes_route@27 __puya_arc4_router___verify_select_uint64_route@28 __puya_arc4_router___verify_setbit_bytes_route@29 __puya_arc4_router___verify_setbit_uint64_route@30 __puya_arc4_router___verify_setbyte_route@31 __puya_arc4_router___verify_shl_route@32 __puya_arc4_router___verify_shr_route@33 __puya_arc4_router___verify_sqrt_route@34 __puya_arc4_router___verify_substring_route@35
    intc_1 // 0
    retsub

__puya_arc4_router___verify_addw_route@2:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_base64_decode_standard_route@3:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts: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
    retsub

__puya_arc4_router___verify_base64_decode_url_route@4:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bytes_bitlen_route@5:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_uint64_bitlen_route@6:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bsqrt_route@7:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_btoi_route@8:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bzero_route@9:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_concat_route@10:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_divmodw_route@11:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63
    // @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
    retsub

__puya_arc4_router___verify_divw_route@12:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_err_route@13:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    callsub verify_err
    intc_0 // 1
    retsub

__puya_arc4_router___verify_exp_route@14:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_expw_route@15:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_route@16:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_from_2_route@17:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:98
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:98
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint16_route@18:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:104
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:104
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint32_route@19:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:110
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:110
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint64_route@20:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:116
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:116
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbit_bytes_route@21:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:122
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:122
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbit_uint64_route@22:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:128
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:128
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbyte_route@23:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:134
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:134
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_itob_route@24:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:140
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:140
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_mulw_route@25:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:146
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:146
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_replace_route@26:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:152
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:152
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_select_bytes_route@27:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:158
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:158
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_select_uint64_route@28:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:164
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:164
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbit_bytes_route@29:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:170
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:170
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbit_uint64_route@30:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:176
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:176
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbyte_route@31:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:182
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:182
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_shl_route@32:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:188
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:188
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_shr_route@33:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:194
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:194
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_sqrt_route@34:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:200
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:200
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_substring_route@35:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:206
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is NoOp
    txn ApplicationID
    assert // is not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:206
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___bare_routing@38:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txn OnCompletion
    bnz __puya_arc4_router___after_if_else@42
    txn ApplicationID
    !
    assert // is creating
    intc_0 // 1
    retsub

__puya_arc4_router___after_if_else@42:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    intc_1 // 0
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4-5
    // @arc4.abimethod()
    // public verify_addw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:6
    // const result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:7
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:10-11
    // @arc4.abimethod()
    // public verify_base64_decode_standard(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:12
    // const result = op.base64Decode(Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:13
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16-17
    // @arc4.abimethod()
    // public verify_base64_decode_url(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:18
    // const result = op.base64Decode(Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:19
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22-23
    // @arc4.abimethod()
    // public verify_bytes_bitlen(a: bytes, pad_a_size: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:24
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -1
    bzero
    frame_dig -2
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:25
    // const result = op.bitLength(paddedA)
    bitlen
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:26
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29-30
    // @arc4.abimethod()
    // public verify_uint64_bitlen(a: uint64): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:31
    // const result = op.bitLength(a)
    frame_dig -1
    bitlen
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:32
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35-36
    // @arc4.abimethod()
    // public verify_bsqrt(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:38
    // const result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:39
    // return Bytes(result)
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42-43
    // @arc4.abimethod()
    // public verify_btoi(a: bytes): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:44
    // const result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:45
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48-49
    // @arc4.abimethod()
    // public verify_bzero(a: uint64): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:50
    // const result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:51
    // return op.sha256(result)
    sha256
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54-55
    // @arc4.abimethod()
    // public verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64): bytes {
    proto 4 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:56
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -2
    bzero
    frame_dig -4
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:57
    // const paddedB = op.bzero(pad_b_size).concat(b)
    frame_dig -1
    bzero
    frame_dig -3
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:58
    // const result = paddedA.concat(paddedB)
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:59
    // const resultHash = op.sha256(result)
    sha256
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:60
    // return resultHash
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63-64
    // @arc4.abimethod()
    // public verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64): readonly [uint64, uint64, uint64, uint64] {
    proto 4 4
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:65
    // const result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:66
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69-70
    // @arc4.abimethod()
    // public verify_divw(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:71
    // const result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:72
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_err() -> void:
verify_err:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:75-76
    // @arc4.abimethod()
    // public verify_err(): void {
    proto 0 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:77
    // err()
    err


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80-81
    // @arc4.abimethod()
    // public verify_exp(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:82
    // const result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:83
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86-87
    // @arc4.abimethod()
    // public verify_expw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:88
    // const result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:89
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92-93
    // @arc4.abimethod()
    // public verify_extract(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:94
    // const result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:95
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:98-99
    // @arc4.abimethod()
    // public verify_extract_from_2(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:100
    // const result = op.extract(a, 2, 0)
    frame_dig -1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:101
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:104-105
    // @arc4.abimethod()
    // public verify_extract_uint16(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:106
    // const result = op.extractUint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:107
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:110-111
    // @arc4.abimethod()
    // public verify_extract_uint32(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:112
    // const result = op.extractUint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:113
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:116-117
    // @arc4.abimethod()
    // public verify_extract_uint64(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:118
    // const result = op.extractUint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:119
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:122-123
    // @arc4.abimethod()
    // public verify_getbit_bytes(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:124
    // const result = op.getBit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:125
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:128-129
    // @arc4.abimethod()
    // public verify_getbit_uint64(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:130
    // const result = op.getBit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:131
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:134-135
    // @arc4.abimethod()
    // public verify_getbyte(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:136
    // const result = op.getByte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:137
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:140-141
    // @arc4.abimethod()
    // public verify_itob(a: uint64): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:142
    // const result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:143
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:146-147
    // @arc4.abimethod()
    // public verify_mulw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:148
    // const result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:149
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:152-153
    // @arc4.abimethod()
    // public verify_replace(a: bytes, b: uint64, c: bytes): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154
    // const result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:155
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:158-159
    // @arc4.abimethod()
    // public verify_select_bytes(a: bytes, b: bytes, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160
    // const result = op.select(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:161
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:164-165
    // @arc4.abimethod()
    // public verify_select_uint64(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166
    // const result = op.select(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:167
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:170-171
    // @arc4.abimethod()
    // public verify_setbit_bytes(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172
    // const result = op.setBit(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:173
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:176-177
    // @arc4.abimethod()
    // public verify_setbit_uint64(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178
    // const result = op.setBit(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:179
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:182-183
    // @arc4.abimethod()
    // public verify_setbyte(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184
    // const result = op.setByte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:185
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:188-189
    // @arc4.abimethod()
    // public verify_shl(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190
    // const result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:191
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:194-195
    // @arc4.abimethod()
    // public verify_shr(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196
    // const result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:197
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:200-201
    // @arc4.abimethod()
    // public verify_sqrt(a: uint64): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202
    // const result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:203
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:206-207
    // @arc4.abimethod()
    // public verify_substring(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208
    // const result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:209
    // return result
    retsub
", + "approval": "#pragma version 10

tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.approvalProgram:
    intcblock 1 0
    bytecblock 0x151f7c75
    callsub __puya_arc4_router__
    return


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.__puya_arc4_router__() -> uint64:
__puya_arc4_router__:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    proto 0 1
    txn NumAppArgs
    bz __puya_arc4_router___bare_routing@39
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xc58d30e0 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a // 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_bytes_len(byte[],uint64)uint64", 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[]"
    txna ApplicationArgs 0
    match __puya_arc4_router___verify_addw_route@2 __puya_arc4_router___verify_base64_decode_standard_route@3 __puya_arc4_router___verify_base64_decode_url_route@4 __puya_arc4_router___verify_bytes_bitlen_route@5 __puya_arc4_router___verify_uint64_bitlen_route@6 __puya_arc4_router___verify_bsqrt_route@7 __puya_arc4_router___verify_btoi_route@8 __puya_arc4_router___verify_bzero_route@9 __puya_arc4_router___verify_concat_route@10 __puya_arc4_router___verify_divmodw_route@11 __puya_arc4_router___verify_divw_route@12 __puya_arc4_router___verify_err_route@13 __puya_arc4_router___verify_exp_route@14 __puya_arc4_router___verify_expw_route@15 __puya_arc4_router___verify_extract_route@16 __puya_arc4_router___verify_extract_from_2_route@17 __puya_arc4_router___verify_extract_uint16_route@18 __puya_arc4_router___verify_extract_uint32_route@19 __puya_arc4_router___verify_extract_uint64_route@20 __puya_arc4_router___verify_getbit_bytes_route@21 __puya_arc4_router___verify_getbit_uint64_route@22 __puya_arc4_router___verify_getbyte_route@23 __puya_arc4_router___verify_itob_route@24 __puya_arc4_router___verify_bytes_len_route@25 __puya_arc4_router___verify_mulw_route@26 __puya_arc4_router___verify_replace_route@27 __puya_arc4_router___verify_select_bytes_route@28 __puya_arc4_router___verify_select_uint64_route@29 __puya_arc4_router___verify_setbit_bytes_route@30 __puya_arc4_router___verify_setbit_uint64_route@31 __puya_arc4_router___verify_setbyte_route@32 __puya_arc4_router___verify_shl_route@33 __puya_arc4_router___verify_shr_route@34 __puya_arc4_router___verify_sqrt_route@35 __puya_arc4_router___verify_substring_route@36
    intc_1 // 0
    retsub

__puya_arc4_router___verify_addw_route@2:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_base64_decode_standard_route@3:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts: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
    retsub

__puya_arc4_router___verify_base64_decode_url_route@4:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bytes_bitlen_route@5:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_uint64_bitlen_route@6:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bsqrt_route@7:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_btoi_route@8:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bzero_route@9:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_concat_route@10:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_divmodw_route@11:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63
    // @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
    retsub

__puya_arc4_router___verify_divw_route@12:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_err_route@13:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub verify_err
    intc_0 // 1
    retsub

__puya_arc4_router___verify_exp_route@14:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_expw_route@15:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_route@16:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_from_2_route@17:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:99
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:99
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint16_route@18:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:105
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:105
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint32_route@19:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:111
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint64_route@20:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:117
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:117
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbit_bytes_route@21:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:123
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:123
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbit_uint64_route@22:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:129
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbyte_route@23:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:135
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:135
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_itob_route@24:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:141
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bytes_len_route@25:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:147
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:147
    // @arc4.abimethod()
    callsub verify_bytes_len
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_mulw_route@26:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_replace_route@27:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_select_bytes_route@28:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_select_uint64_route@29:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbit_bytes_route@30:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbit_uint64_route@31:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbyte_route@32:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_shl_route@33:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_shr_route@34:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_sqrt_route@35:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_substring_route@36:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:214
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:214
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___bare_routing@39:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txn OnCompletion
    bnz __puya_arc4_router___after_if_else@43
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    retsub

__puya_arc4_router___after_if_else@43:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    intc_1 // 0
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4-5
    // @arc4.abimethod()
    // public verify_addw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:6
    // const result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:7
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:10-11
    // @arc4.abimethod()
    // public verify_base64_decode_standard(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:12
    // const result = op.base64Decode(Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:13
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16-17
    // @arc4.abimethod()
    // public verify_base64_decode_url(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:18
    // const result = op.base64Decode(Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:19
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22-23
    // @arc4.abimethod()
    // public verify_bytes_bitlen(a: bytes, pad_a_size: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:24
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -1
    bzero
    frame_dig -2
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:25
    // const result = op.bitLength(paddedA)
    bitlen
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:26
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29-30
    // @arc4.abimethod()
    // public verify_uint64_bitlen(a: uint64): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:31
    // const result = op.bitLength(a)
    frame_dig -1
    bitlen
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:32
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35-36
    // @arc4.abimethod()
    // public verify_bsqrt(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:38
    // const result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:39
    // return Bytes(result)
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42-43
    // @arc4.abimethod()
    // public verify_btoi(a: bytes): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:44
    // const result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:45
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48-49
    // @arc4.abimethod()
    // public verify_bzero(a: uint64): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:50
    // const result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:51
    // return op.sha256(result)
    sha256
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54-55
    // @arc4.abimethod()
    // public verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64): bytes {
    proto 4 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:56
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -2
    bzero
    frame_dig -4
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:57
    // const paddedB = op.bzero(pad_b_size).concat(b)
    frame_dig -1
    bzero
    frame_dig -3
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:58
    // const result = paddedA.concat(paddedB)
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:59
    // const resultHash = op.sha256(result)
    sha256
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:60
    // return resultHash
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63-64
    // @arc4.abimethod()
    // public verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64): readonly [uint64, uint64, uint64, uint64] {
    proto 4 4
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:65
    // const result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:66
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69-70
    // @arc4.abimethod()
    // public verify_divw(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:71
    // const result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:72
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_err() -> void:
verify_err:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:75-76
    // @arc4.abimethod()
    // public verify_err(): void {
    proto 0 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:77
    // err()
    err


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80-81
    // @arc4.abimethod()
    // public verify_exp(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:82
    // const result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:83
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86-87
    // @arc4.abimethod()
    // public verify_expw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:88
    // const result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:89
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92-93
    // @arc4.abimethod()
    // public verify_extract(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:94
    // const result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:95
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:99-100
    // @arc4.abimethod()
    // public verify_extract_from_2(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:101
    // const result = op.extract(a, 2, 0)
    frame_dig -1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:102
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:105-106
    // @arc4.abimethod()
    // public verify_extract_uint16(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:107
    // const result = op.extractUint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:108
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:111-112
    // @arc4.abimethod()
    // public verify_extract_uint32(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:113
    // const result = op.extractUint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:114
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:117-118
    // @arc4.abimethod()
    // public verify_extract_uint64(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:119
    // const result = op.extractUint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:120
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:123-124
    // @arc4.abimethod()
    // public verify_getbit_bytes(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:125
    // const result = op.getBit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:126
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:129-130
    // @arc4.abimethod()
    // public verify_getbit_uint64(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:131
    // const result = op.getBit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:132
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:135-136
    // @arc4.abimethod()
    // public verify_getbyte(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:137
    // const result = op.getByte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:138
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:141-142
    // @arc4.abimethod()
    // public verify_itob(a: uint64): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:143
    // const result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:144
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bytes_len(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_len:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:147-148
    // @arc4.abimethod()
    // public verify_bytes_len(a: bytes, pad_a_size: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:149
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -1
    bzero
    frame_dig -2
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:150
    // const result = op.len(paddedA)
    len
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:151
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154-155
    // @arc4.abimethod()
    // public verify_mulw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:156
    // const result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:157
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160-161
    // @arc4.abimethod()
    // public verify_replace(a: bytes, b: uint64, c: bytes): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:162
    // const result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:163
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166-167
    // @arc4.abimethod()
    // public verify_select_bytes(a: bytes, b: bytes, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:168
    // const result = op.select(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:169
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172-173
    // @arc4.abimethod()
    // public verify_select_uint64(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:174
    // const result = op.select(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:175
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178-179
    // @arc4.abimethod()
    // public verify_setbit_bytes(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:180
    // const result = op.setBit(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:181
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184-185
    // @arc4.abimethod()
    // public verify_setbit_uint64(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:186
    // const result = op.setBit(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:187
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190-191
    // @arc4.abimethod()
    // public verify_setbyte(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:192
    // const result = op.setByte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:193
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196-197
    // @arc4.abimethod()
    // public verify_shl(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:198
    // const result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:199
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202-203
    // @arc4.abimethod()
    // public verify_shr(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:204
    // const result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:205
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208-209
    // @arc4.abimethod()
    // public verify_sqrt(a: uint64): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:210
    // const result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:211
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:214-215
    // @arc4.abimethod()
    // public verify_substring(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:216
    // const result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:217
    // return result
    retsub
", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy9hcnRpZmFjdHMvbWlzY2VsbGFuZW91cy1vcHMvY29udHJhY3QuYWxnby50czo6TWlzY2VsbGFuZW91c09wc0NvbnRyYWN0LmNsZWFyU3RhdGVQcm9ncmFtOgogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgo=" }, "state": { @@ -572,6 +577,23 @@ "type": "byte[]" } }, + { + "name": "verify_bytes_len", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "pad_a_size" + } + ], + "readonly": false, + "returns": { + "type": "uint64" + } + }, { "name": "verify_mulw", "args": [ diff --git a/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc56.json b/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc56.json new file mode 100644 index 0000000..2c01953 --- /dev/null +++ b/tests/artifacts/miscellaneous-ops/data/MiscellaneousOpsContract.arc56.json @@ -0,0 +1,1024 @@ +{ + "name": "MiscellaneousOpsContract", + "structs": {}, + "methods": [ + { + "name": "verify_addw", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "(uint64,uint64)" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_base64_decode_standard", + "args": [ + { + "type": "byte[]", + "name": "a" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_base64_decode_url", + "args": [ + { + "type": "byte[]", + "name": "a" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_bytes_bitlen", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "pad_a_size" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_uint64_bitlen", + "args": [ + { + "type": "uint64", + "name": "a" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_bsqrt", + "args": [ + { + "type": "byte[]", + "name": "a" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_btoi", + "args": [ + { + "type": "byte[]", + "name": "a" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_bzero", + "args": [ + { + "type": "uint64", + "name": "a" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_concat", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "byte[]", + "name": "b" + }, + { + "type": "uint64", + "name": "pad_a_size" + }, + { + "type": "uint64", + "name": "pad_b_size" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_divmodw", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + }, + { + "type": "uint64", + "name": "d" + } + ], + "returns": { + "type": "(uint64,uint64,uint64,uint64)" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_divw", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_err", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_exp", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_expw", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "(uint64,uint64)" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_extract", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_extract_from_2", + "args": [ + { + "type": "byte[]", + "name": "a" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_extract_uint16", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_extract_uint32", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_extract_uint64", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_getbit_bytes", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_getbit_uint64", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_getbyte", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_itob", + "args": [ + { + "type": "uint64", + "name": "a" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_bytes_len", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "pad_a_size" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_mulw", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "(uint64,uint64)" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_replace", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "byte[]", + "name": "c" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_select_bytes", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "byte[]", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_select_uint64", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_setbit_bytes", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_setbit_uint64", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_setbyte", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_shl", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_shr", + "args": [ + { + "type": "uint64", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_sqrt", + "args": [ + { + "type": "uint64", + "name": "a" + } + ], + "returns": { + "type": "uint64" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + }, + { + "name": "verify_substring", + "args": [ + { + "type": "byte[]", + "name": "a" + }, + { + "type": "uint64", + "name": "b" + }, + { + "type": "uint64", + "name": "c" + } + ], + "returns": { + "type": "byte[]" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + }, + "readonly": false, + "events": [], + "recommendations": {} + } + ], + "arcs": [ + 22, + 28 + ], + "networks": {}, + "state": { + "schema": { + "global": { + "ints": 0, + "bytes": 0 + }, + "local": { + "ints": 0, + "bytes": 0 + } + }, + "keys": { + "global": {}, + "local": {}, + "box": {} + }, + "maps": { + "global": {}, + "local": {}, + "box": {} + } + }, + "bareActions": { + "create": [ + "NoOp" + ], + "call": [] + }, + "sourceInfo": { + "approval": { + "sourceInfo": [ + { + "pc": [ + 281, + 310, + 340, + 370, + 397, + 418, + 448, + 471, + 499, + 543, + 597, + 626, + 638, + 663, + 692, + 730, + 760, + 787, + 814, + 841, + 868, + 893, + 920, + 948, + 975, + 1004, + 1044, + 1084, + 1113, + 1151, + 1180, + 1218, + 1243, + 1268, + 1289 + ], + "errorMessage": "OnCompletion is not NoOp" + }, + { + "pc": [ + 1332 + ], + "errorMessage": "can only call when creating" + }, + { + "pc": [ + 284, + 313, + 343, + 373, + 400, + 421, + 451, + 474, + 502, + 546, + 600, + 629, + 641, + 666, + 695, + 733, + 763, + 790, + 817, + 844, + 871, + 896, + 923, + 951, + 978, + 1007, + 1047, + 1087, + 1116, + 1154, + 1183, + 1221, + 1246, + 1271, + 1292 + ], + "errorMessage": "can only call when not creating" + } + ], + "pcOffsetMethod": "none" + }, + "clear": { + "sourceInfo": [], + "pcOffsetMethod": "none" + } + }, + "source": { + "approval": "#pragma version 10

tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.approvalProgram:
    intcblock 1 0
    bytecblock 0x151f7c75
    callsub __puya_arc4_router__
    return


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.__puya_arc4_router__() -> uint64:
__puya_arc4_router__:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    proto 0 1
    txn NumAppArgs
    bz __puya_arc4_router___bare_routing@39
    pushbytess 0x45847eea 0xf57aceb5 0x7d631730 0xa1b24441 0xcd7be1ac 0x7cfda64b 0x54a910d9 0xc46568de 0x7a46a6ae 0x04372209 0x7e5f6d72 0x24ebcf84 0x9c0b3397 0x0ad40da4 0x95178870 0xdeedc99b 0xab2150bb 0x02a54017 0x3db66b41 0xc7ea8c2a 0x1dcea50c 0x16166f9a 0x2f472065 0xc58d30e0 0xd5a739c3 0x61f3b3e1 0x56cf368b 0x919ffbd2 0x8e30f4e7 0x89f81d92 0xd5260327 0x114c8c6d 0x39e9e62a 0xd6a4c05e 0x1ef8151a // 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_bytes_len(byte[],uint64)uint64", 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[]"
    txna ApplicationArgs 0
    match __puya_arc4_router___verify_addw_route@2 __puya_arc4_router___verify_base64_decode_standard_route@3 __puya_arc4_router___verify_base64_decode_url_route@4 __puya_arc4_router___verify_bytes_bitlen_route@5 __puya_arc4_router___verify_uint64_bitlen_route@6 __puya_arc4_router___verify_bsqrt_route@7 __puya_arc4_router___verify_btoi_route@8 __puya_arc4_router___verify_bzero_route@9 __puya_arc4_router___verify_concat_route@10 __puya_arc4_router___verify_divmodw_route@11 __puya_arc4_router___verify_divw_route@12 __puya_arc4_router___verify_err_route@13 __puya_arc4_router___verify_exp_route@14 __puya_arc4_router___verify_expw_route@15 __puya_arc4_router___verify_extract_route@16 __puya_arc4_router___verify_extract_from_2_route@17 __puya_arc4_router___verify_extract_uint16_route@18 __puya_arc4_router___verify_extract_uint32_route@19 __puya_arc4_router___verify_extract_uint64_route@20 __puya_arc4_router___verify_getbit_bytes_route@21 __puya_arc4_router___verify_getbit_uint64_route@22 __puya_arc4_router___verify_getbyte_route@23 __puya_arc4_router___verify_itob_route@24 __puya_arc4_router___verify_bytes_len_route@25 __puya_arc4_router___verify_mulw_route@26 __puya_arc4_router___verify_replace_route@27 __puya_arc4_router___verify_select_bytes_route@28 __puya_arc4_router___verify_select_uint64_route@29 __puya_arc4_router___verify_setbit_bytes_route@30 __puya_arc4_router___verify_setbit_uint64_route@31 __puya_arc4_router___verify_setbyte_route@32 __puya_arc4_router___verify_shl_route@33 __puya_arc4_router___verify_shr_route@34 __puya_arc4_router___verify_sqrt_route@35 __puya_arc4_router___verify_substring_route@36
    intc_1 // 0
    retsub

__puya_arc4_router___verify_addw_route@2:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4
    // @arc4.abimethod()
    callsub verify_addw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_base64_decode_standard_route@3:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:10
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts: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
    retsub

__puya_arc4_router___verify_base64_decode_url_route@4:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16
    // @arc4.abimethod()
    callsub verify_base64_decode_url
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bytes_bitlen_route@5:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22
    // @arc4.abimethod()
    callsub verify_bytes_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_uint64_bitlen_route@6:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29
    // @arc4.abimethod()
    callsub verify_uint64_bitlen
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bsqrt_route@7:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35
    // @arc4.abimethod()
    callsub verify_bsqrt
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_btoi_route@8:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42
    // @arc4.abimethod()
    callsub verify_btoi
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bzero_route@9:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48
    // @arc4.abimethod()
    callsub verify_bzero
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_concat_route@10:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54
    // @arc4.abimethod()
    callsub verify_concat
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_divmodw_route@11:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    txna ApplicationArgs 4
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63
    // @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
    retsub

__puya_arc4_router___verify_divw_route@12:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69
    // @arc4.abimethod()
    callsub verify_divw
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_err_route@13:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:75
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    callsub verify_err
    intc_0 // 1
    retsub

__puya_arc4_router___verify_exp_route@14:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80
    // @arc4.abimethod()
    callsub verify_exp
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_expw_route@15:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86
    // @arc4.abimethod()
    callsub verify_expw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_route@16:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92
    // @arc4.abimethod()
    callsub verify_extract
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_from_2_route@17:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:99
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:99
    // @arc4.abimethod()
    callsub verify_extract_from_2
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint16_route@18:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:105
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:105
    // @arc4.abimethod()
    callsub verify_extract_uint16
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint32_route@19:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:111
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:111
    // @arc4.abimethod()
    callsub verify_extract_uint32
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_extract_uint64_route@20:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:117
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:117
    // @arc4.abimethod()
    callsub verify_extract_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbit_bytes_route@21:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:123
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:123
    // @arc4.abimethod()
    callsub verify_getbit_bytes
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbit_uint64_route@22:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:129
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:129
    // @arc4.abimethod()
    callsub verify_getbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_getbyte_route@23:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:135
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:135
    // @arc4.abimethod()
    callsub verify_getbyte
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_itob_route@24:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:141
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:141
    // @arc4.abimethod()
    callsub verify_itob
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_bytes_len_route@25:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:147
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:147
    // @arc4.abimethod()
    callsub verify_bytes_len
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_mulw_route@26:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154
    // @arc4.abimethod()
    callsub verify_mulw
    swap
    itob
    swap
    itob
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_replace_route@27:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    extract 2 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160
    // @arc4.abimethod()
    callsub verify_replace
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_select_bytes_route@28:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    extract 2 0
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166
    // @arc4.abimethod()
    callsub verify_select_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_select_uint64_route@29:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172
    // @arc4.abimethod()
    callsub verify_select_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbit_bytes_route@30:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178
    // @arc4.abimethod()
    callsub verify_setbit_bytes
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbit_uint64_route@31:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184
    // @arc4.abimethod()
    callsub verify_setbit_uint64
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_setbyte_route@32:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190
    // @arc4.abimethod()
    callsub verify_setbyte
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_shl_route@33:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196
    // @arc4.abimethod()
    callsub verify_shl
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_shr_route@34:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    txna ApplicationArgs 2
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202
    // @arc4.abimethod()
    callsub verify_shr
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_sqrt_route@35:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208
    // @arc4.abimethod()
    callsub verify_sqrt
    itob
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___verify_substring_route@36:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:214
    // @arc4.abimethod()
    txn OnCompletion
    !
    assert // OnCompletion is not NoOp
    txn ApplicationID
    assert // can only call when not creating
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txna ApplicationArgs 1
    extract 2 0
    txna ApplicationArgs 2
    btoi
    txna ApplicationArgs 3
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:214
    // @arc4.abimethod()
    callsub verify_substring
    dup
    len
    itob
    extract 6 2
    swap
    concat
    bytec_0 // 0x151f7c75
    swap
    concat
    log
    intc_0 // 1
    retsub

__puya_arc4_router___bare_routing@39:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    txn OnCompletion
    bnz __puya_arc4_router___after_if_else@43
    txn ApplicationID
    !
    assert // can only call when creating
    intc_0 // 1
    retsub

__puya_arc4_router___after_if_else@43:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:3
    // export class MiscellaneousOpsContract extends arc4.Contract {
    intc_1 // 0
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_addw(a: uint64, b: uint64) -> uint64, uint64:
verify_addw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:4-5
    // @arc4.abimethod()
    // public verify_addw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:6
    // const result = op.addw(a, b)
    frame_dig -2
    frame_dig -1
    addw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:7
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_base64_decode_standard(a: bytes) -> bytes:
verify_base64_decode_standard:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:10-11
    // @arc4.abimethod()
    // public verify_base64_decode_standard(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:12
    // const result = op.base64Decode(Base64.StdEncoding, a)
    frame_dig -1
    base64_decode StdEncoding
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:13
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_base64_decode_url(a: bytes) -> bytes:
verify_base64_decode_url:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:16-17
    // @arc4.abimethod()
    // public verify_base64_decode_url(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:18
    // const result = op.base64Decode(Base64.URLEncoding, a)
    frame_dig -1
    base64_decode URLEncoding
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:19
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bytes_bitlen(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_bitlen:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:22-23
    // @arc4.abimethod()
    // public verify_bytes_bitlen(a: bytes, pad_a_size: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:24
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -1
    bzero
    frame_dig -2
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:25
    // const result = op.bitLength(paddedA)
    bitlen
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:26
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_uint64_bitlen(a: uint64) -> uint64:
verify_uint64_bitlen:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:29-30
    // @arc4.abimethod()
    // public verify_uint64_bitlen(a: uint64): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:31
    // const result = op.bitLength(a)
    frame_dig -1
    bitlen
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:32
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bsqrt(a: bytes) -> bytes:
verify_bsqrt:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:35-36
    // @arc4.abimethod()
    // public verify_bsqrt(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:38
    // const result = op.bsqrt(a_biguint)
    frame_dig -1
    bsqrt
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:39
    // return Bytes(result)
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_btoi(a: bytes) -> uint64:
verify_btoi:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:42-43
    // @arc4.abimethod()
    // public verify_btoi(a: bytes): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:44
    // const result = op.btoi(a)
    frame_dig -1
    btoi
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:45
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bzero(a: uint64) -> bytes:
verify_bzero:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:48-49
    // @arc4.abimethod()
    // public verify_bzero(a: uint64): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:50
    // const result = op.bzero(a)
    frame_dig -1
    bzero
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:51
    // return op.sha256(result)
    sha256
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64) -> bytes:
verify_concat:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:54-55
    // @arc4.abimethod()
    // public verify_concat(a: bytes, b: bytes, pad_a_size: uint64, pad_b_size: uint64): bytes {
    proto 4 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:56
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -2
    bzero
    frame_dig -4
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:57
    // const paddedB = op.bzero(pad_b_size).concat(b)
    frame_dig -1
    bzero
    frame_dig -3
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:58
    // const result = paddedA.concat(paddedB)
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:59
    // const resultHash = op.sha256(result)
    sha256
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:60
    // return resultHash
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64) -> uint64, uint64, uint64, uint64:
verify_divmodw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:63-64
    // @arc4.abimethod()
    // public verify_divmodw(a: uint64, b: uint64, c: uint64, d: uint64): readonly [uint64, uint64, uint64, uint64] {
    proto 4 4
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:65
    // const result = op.divmodw(a, b, c, d)
    frame_dig -4
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divmodw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:66
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_divw(a: uint64, b: uint64, c: uint64) -> uint64:
verify_divw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:69-70
    // @arc4.abimethod()
    // public verify_divw(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:71
    // const result = op.divw(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    divw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:72
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_err() -> void:
verify_err:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:75-76
    // @arc4.abimethod()
    // public verify_err(): void {
    proto 0 0
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:77
    // err()
    err


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_exp(a: uint64, b: uint64) -> uint64:
verify_exp:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:80-81
    // @arc4.abimethod()
    // public verify_exp(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:82
    // const result = op.exp(a, b)
    frame_dig -2
    frame_dig -1
    exp
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:83
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_expw(a: uint64, b: uint64) -> uint64, uint64:
verify_expw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:86-87
    // @arc4.abimethod()
    // public verify_expw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:88
    // const result = op.expw(a, b)
    frame_dig -2
    frame_dig -1
    expw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:89
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract(a: bytes, b: uint64, c: uint64) -> bytes:
verify_extract:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:92-93
    // @arc4.abimethod()
    // public verify_extract(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:94
    // const result = op.extract(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    extract3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:95
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_from_2(a: bytes) -> bytes:
verify_extract_from_2:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:99-100
    // @arc4.abimethod()
    // public verify_extract_from_2(a: bytes): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:101
    // const result = op.extract(a, 2, 0)
    frame_dig -1
    pushint 2 // 2
    intc_1 // 0
    extract3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:102
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint16(a: bytes, b: uint64) -> uint64:
verify_extract_uint16:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:105-106
    // @arc4.abimethod()
    // public verify_extract_uint16(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:107
    // const result = op.extractUint16(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint16
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:108
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint32(a: bytes, b: uint64) -> uint64:
verify_extract_uint32:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:111-112
    // @arc4.abimethod()
    // public verify_extract_uint32(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:113
    // const result = op.extractUint32(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint32
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:114
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_extract_uint64(a: bytes, b: uint64) -> uint64:
verify_extract_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:117-118
    // @arc4.abimethod()
    // public verify_extract_uint64(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:119
    // const result = op.extractUint64(a, b)
    frame_dig -2
    frame_dig -1
    extract_uint64
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:120
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_bytes(a: bytes, b: uint64) -> uint64:
verify_getbit_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:123-124
    // @arc4.abimethod()
    // public verify_getbit_bytes(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:125
    // const result = op.getBit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:126
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbit_uint64(a: uint64, b: uint64) -> uint64:
verify_getbit_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:129-130
    // @arc4.abimethod()
    // public verify_getbit_uint64(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:131
    // const result = op.getBit(a, b)
    frame_dig -2
    frame_dig -1
    getbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:132
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_getbyte(a: bytes, b: uint64) -> uint64:
verify_getbyte:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:135-136
    // @arc4.abimethod()
    // public verify_getbyte(a: bytes, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:137
    // const result = op.getByte(a, b)
    frame_dig -2
    frame_dig -1
    getbyte
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:138
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_itob(a: uint64) -> bytes:
verify_itob:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:141-142
    // @arc4.abimethod()
    // public verify_itob(a: uint64): bytes {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:143
    // const result = op.itob(a)
    frame_dig -1
    itob
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:144
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_bytes_len(a: bytes, pad_a_size: uint64) -> uint64:
verify_bytes_len:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:147-148
    // @arc4.abimethod()
    // public verify_bytes_len(a: bytes, pad_a_size: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:149
    // const paddedA = op.bzero(pad_a_size).concat(a)
    frame_dig -1
    bzero
    frame_dig -2
    concat
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:150
    // const result = op.len(paddedA)
    len
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:151
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_mulw(a: uint64, b: uint64) -> uint64, uint64:
verify_mulw:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:154-155
    // @arc4.abimethod()
    // public verify_mulw(a: uint64, b: uint64): readonly [uint64, uint64] {
    proto 2 2
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:156
    // const result = op.mulw(a, b)
    frame_dig -2
    frame_dig -1
    mulw
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:157
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_replace(a: bytes, b: uint64, c: bytes) -> bytes:
verify_replace:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:160-161
    // @arc4.abimethod()
    // public verify_replace(a: bytes, b: uint64, c: bytes): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:162
    // const result = op.replace(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    replace3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:163
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_bytes(a: bytes, b: bytes, c: uint64) -> bytes:
verify_select_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:166-167
    // @arc4.abimethod()
    // public verify_select_bytes(a: bytes, b: bytes, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:168
    // const result = op.select(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:169
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_select_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_select_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:172-173
    // @arc4.abimethod()
    // public verify_select_uint64(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:174
    // const result = op.select(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    select
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:175
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_bytes(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbit_bytes:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:178-179
    // @arc4.abimethod()
    // public verify_setbit_bytes(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:180
    // const result = op.setBit(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:181
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbit_uint64(a: uint64, b: uint64, c: uint64) -> uint64:
verify_setbit_uint64:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:184-185
    // @arc4.abimethod()
    // public verify_setbit_uint64(a: uint64, b: uint64, c: uint64): uint64 {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:186
    // const result = op.setBit(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbit
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:187
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_setbyte(a: bytes, b: uint64, c: uint64) -> bytes:
verify_setbyte:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:190-191
    // @arc4.abimethod()
    // public verify_setbyte(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:192
    // const result = op.setByte(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    setbyte
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:193
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shl(a: uint64, b: uint64) -> uint64:
verify_shl:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:196-197
    // @arc4.abimethod()
    // public verify_shl(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:198
    // const result = op.shl(a, b)
    frame_dig -2
    frame_dig -1
    shl
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:199
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_shr(a: uint64, b: uint64) -> uint64:
verify_shr:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:202-203
    // @arc4.abimethod()
    // public verify_shr(a: uint64, b: uint64): uint64 {
    proto 2 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:204
    // const result = op.shr(a, b)
    frame_dig -2
    frame_dig -1
    shr
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:205
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_sqrt(a: uint64) -> uint64:
verify_sqrt:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:208-209
    // @arc4.abimethod()
    // public verify_sqrt(a: uint64): uint64 {
    proto 1 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:210
    // const result = op.sqrt(a)
    frame_dig -1
    sqrt
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:211
    // return result
    retsub


// tests/artifacts/miscellaneous-ops/contract.algo.ts::MiscellaneousOpsContract.verify_substring(a: bytes, b: uint64, c: uint64) -> bytes:
verify_substring:
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:214-215
    // @arc4.abimethod()
    // public verify_substring(a: bytes, b: uint64, c: uint64): bytes {
    proto 3 1
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:216
    // const result = op.substring(a, b, c)
    frame_dig -3
    frame_dig -2
    frame_dig -1
    substring3
    // tests/artifacts/miscellaneous-ops/contract.algo.ts:217
    // return result
    retsub
", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEwCgp0ZXN0cy9hcnRpZmFjdHMvbWlzY2VsbGFuZW91cy1vcHMvY29udHJhY3QuYWxnby50czo6TWlzY2VsbGFuZW91c09wc0NvbnRyYWN0LmNsZWFyU3RhdGVQcm9ncmFtOgogICAgcHVzaGludCAxIC8vIDEKICAgIHJldHVybgo=" + }, + "events": [], + "templateVariables": {} +} \ No newline at end of file diff --git a/tests/pure-op-codes.spec.ts b/tests/pure-op-codes.spec.ts index 9f795c4..7ab8575 100644 --- a/tests/pure-op-codes.spec.ts +++ b/tests/pure-op-codes.spec.ts @@ -672,6 +672,24 @@ describe('Pure op codes', async () => { }) }) + describe('len', async () => { + test.each([ + [Bytes(internal.encodingUtil.bigIntToUint8Array(0n)), 0], + [Bytes(internal.encodingUtil.bigIntToUint8Array(1n)), 0], + [Bytes(internal.encodingUtil.bigIntToUint8Array(MAX_UINT64)), 0], + [Bytes(internal.encodingUtil.bigIntToUint8Array(MAX_UINT512)), 0], + [Bytes(internal.encodingUtil.bigIntToUint8Array(MAX_UINT512 * MAX_UINT512)), 0], + [Bytes(Array(8).fill(0x00).concat(Array(4).fill(0x0f))), 0], + [Bytes([0x0f]), MAX_BYTES_SIZE - 1], + [Bytes(), 0], + ])('should return the length of the bytes input', async (a, padSize) => { + const avmResult = await getAvmResult({ appClient }, 'verify_bytes_len', asUint8Array(a), padSize) + const paddedA = getPaddedBytes(padSize, a) + const result = op.len(paddedA) + expect(result).toEqual(avmResult) + }) + }) + describe('mulw', async () => { test.each([ [0, 0],