From d00548ff28d9c4565edfe03c87f7a74bf9b1cabf Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 9 Apr 2025 08:18:57 -0400 Subject: [PATCH 01/29] wip: initial simple ref check --- src/lib/compiler.ts | 28 ++++++++ .../reference_compile_errors.algo.ts | 68 +++++++++++++++++++ tests/references.test.ts | 38 +++++++++++ 3 files changed, 134 insertions(+) create mode 100644 tests/contracts/reference_compile_errors.algo.ts create mode 100644 tests/references.test.ts diff --git a/src/lib/compiler.ts b/src/lib/compiler.ts index 4110389ea..c8b542031 100644 --- a/src/lib/compiler.ts +++ b/src/lib/compiler.ts @@ -1088,6 +1088,23 @@ export default class Compiler { */ private topLevelNode!: ts.Node; + private mutableRefCheck(e: ts.Node) { + const typeInfo = this.getTypeInfo(e.getType()); + if (typeInfo.kind !== 'base') { + if ( + !( + e.isKind(ts.SyntaxKind.CallExpression) || + e.isKind(ts.SyntaxKind.ArrayLiteralExpression) || + e.isKind(ts.SyntaxKind.ObjectLiteralExpression) + ) + ) { + throw Error( + `Cannot have multiple multiple references to the same object. Use clone to create a deep copy: clone(${e.getText()})` + ); + } + } + } + private getTypeInfo(type: ts.Type): TypeInfo { if (type.getText() === 'SplitUint128') return { kind: 'base', type: 'split uint128' }; if (type.getText() === 'DivmodwOutput') return { kind: 'base', type: 'divmodw output' }; @@ -2038,6 +2055,9 @@ export default class Compiler { if (this.lastType.kind !== 'dynamicArray') throw new Error('Can only push to dynamic array'); if (!this.isDynamicArrayOfStaticType(this.lastType)) throw new Error('Cannot push to dynamic array of dynamic types'); + + this.mutableRefCheck(node.getArguments()[0]); + this.processNode(node.getArguments()[0]); this.checkEncoding(node.getArguments()[0], this.lastType); this.pushVoid(node, 'concat'); @@ -3635,6 +3655,10 @@ export default class Compiler { const { typeHint } = this; if (typeHint === undefined) throw Error('Type hint must be provided to process object or array'); + elements.forEach((e) => { + this.mutableRefCheck(e); + }); + if ( typeHint.kind === 'tuple' || typeHint.kind === 'object' || @@ -4226,6 +4250,8 @@ export default class Compiler { !this.isDynamicType(this.storageProps[getStorageName(storageExpression)!].valueType); if (newValue) { + this.mutableRefCheck(newValue); + if (newValue.getType().isNumberLiteral()) { this.processNewValue(newValue, elem.type); } else { @@ -4336,6 +4362,8 @@ export default class Compiler { } if (newValue) { + this.mutableRefCheck(newValue); + if (this.isDynamicType(element.type)) { if (element.parent?.arrayType !== 'tuple') { throw new Error( diff --git a/tests/contracts/reference_compile_errors.algo.ts b/tests/contracts/reference_compile_errors.algo.ts new file mode 100644 index 000000000..f56200983 --- /dev/null +++ b/tests/contracts/reference_compile_errors.algo.ts @@ -0,0 +1,68 @@ +import { Contract } from '../../src/lib/index'; + +type ArrObj = { + arr: uint64[]; +}; + +export class MutableRefInObjLiteral extends Contract { + mutableRefInObj() { + const arr: uint64[] = [1, 2, 3]; + + const arrObj: ArrObj = { arr: arr }; + + arr[0] = 4; + arrObj.arr[0] = 5; + + assert(arr[0] === arrObj.arr[0]); + } +} + +export class MutableRefInObjAssignment extends Contract { + mutableRefInObj() { + const arr: uint64[] = [1, 2, 3]; + + const arrObj: ArrObj = { arr: [] as uint64[] }; + + arrObj.arr = arr; + + arr[0] = 4; + arrObj.arr[0] = 5; + + assert(arr[0] === arrObj.arr[0]); + } +} + +export class MutableRefInArrayLiteral extends Contract { + mutableRefInArray() { + const arr: uint64[] = [1, 2, 3]; + const arrArr: uint64[][] = [arr]; + + arr[0] = 4; + arrArr[0][0] = 5; + + assert(arr[0] === arrArr[0][0]); + } +} + +export class MutableRefInArrayAssignment extends Contract { + mutableRefInArray() { + const arr: uint64[] = [1, 2, 3]; + const arrArr: uint64[][] = []; + arrArr[0] = arr; + + arr[0] = 4; + arrArr[0][0] = 5; + } +} + +export class MutableRefInPush extends Contract { + mutableRefInPush() { + const arr: uint64[] = [1, 2, 3]; + const arrArr: uint64[][] = []; + arrArr.push(arr); + arr[0] = 4; + arrArr[0][0] = 5; + + assert(arr[0] === arrArr[0][0]); + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts new file mode 100644 index 000000000..095a886db --- /dev/null +++ b/tests/references.test.ts @@ -0,0 +1,38 @@ +import { describe, test, expect, beforeAll } from '@jest/globals'; +import * as algokit from '@algorandfoundation/algokit-utils'; +import path from 'path'; +// eslint-disable-next-line import/no-unresolved +import { ApplicationClient } from '@algorandfoundation/algokit-utils/types/app-client'; +import algosdk from 'algosdk'; +import { getMethodTeal, artifactsTest, algodClient, kmdClient, compileAndCreate, TESTS_PROJECT } from './common'; +import Compiler from '../src/lib/compiler'; + +const ARTIFACTS_DIR = 'tests/contracts/artifacts/'; + +function compilerErrorTest(contractName: string, errorMsg: string) { + test(contractName, async () => { + let msg: string; + try { + await compileAndCreate( + algosdk.generateAccount(), + 'tests/contracts/reference_compile_errors.algo.ts', + ARTIFACTS_DIR, + contractName + ); + msg = 'No error'; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } catch (e: any) { + msg = e.message; + } + + expect(msg).toMatch(errorMsg); + }); +} + +describe('Reference Compile Errors', () => { + compilerErrorTest('MutableRefInObjLiteral', 'Cannot have multiple multiple references to the same object'); + compilerErrorTest('MutableRefInObjAssignment', 'Cannot have multiple multiple references to the same object'); + compilerErrorTest('MutableRefInArrayLiteral', 'Cannot have multiple multiple references to the same object'); + compilerErrorTest('MutableRefInArrayAssignment', 'Cannot have multiple multiple references to the same object'); + compilerErrorTest('MutableRefInPush', 'Cannot push to dynamic array of dynamic types'); +}); From 61033f5792cf23a98e025d61371aff4c78154f21 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 9 Apr 2025 14:49:45 -0400 Subject: [PATCH 02/29] wip: ts-based ref checker --- .../reti/artifacts/StakingPool.approval.teal | 4 +- .../reti/artifacts/StakingPool.arc32.json | 2 +- .../reti/artifacts/StakingPool.arc56.json | 2 +- .../artifacts/ValidatorRegistry.approval.teal | 4 +- .../artifacts/ValidatorRegistry.arc32.json | 2 +- .../artifacts/ValidatorRegistry.arc56.json | 2 +- examples/reti/stakingPool.algo.ts | 2 +- examples/reti/validatorRegistry.algo.ts | 4 +- src/lib/compiler.ts | 106 +++++------ src/lib/ref_checker.ts | 172 ++++++++++++++++++ 10 files changed, 225 insertions(+), 75 deletions(-) create mode 100644 src/lib/ref_checker.ts diff --git a/examples/reti/artifacts/StakingPool.approval.teal b/examples/reti/artifacts/StakingPool.approval.teal index 9c6555881..f3558091c 100644 --- a/examples/reti/artifacts/StakingPool.approval.teal +++ b/examples/reti/artifacts/StakingPool.approval.teal @@ -1668,7 +1668,7 @@ claimTokens: // applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value), // methodArgs: [ // { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }, - // staker, + // clone(staker), // 0, // no algo removed // amountRewardTokenRemoved, // false, // staker isn't being removed. @@ -1689,7 +1689,7 @@ claimTokens: // examples/reti/stakingPool.algo.ts:435 // methodArgs: [ // { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }, - // staker, + // clone(staker), // 0, // no algo removed // amountRewardTokenRemoved, // false, // staker isn't being removed. diff --git a/examples/reti/artifacts/StakingPool.arc32.json b/examples/reti/artifacts/StakingPool.arc32.json index e02810f5d..45c38f522 100644 --- a/examples/reti/artifacts/StakingPool.arc32.json +++ b/examples/reti/artifacts/StakingPool.arc32.json @@ -161,7 +161,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "contract": { diff --git a/examples/reti/artifacts/StakingPool.arc56.json b/examples/reti/artifacts/StakingPool.arc56.json index eeb512929..33a6e27df 100644 --- a/examples/reti/artifacts/StakingPool.arc56.json +++ b/examples/reti/artifacts/StakingPool.arc56.json @@ -19064,7 +19064,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "templateVariables": { diff --git a/examples/reti/artifacts/ValidatorRegistry.approval.teal b/examples/reti/artifacts/ValidatorRegistry.approval.teal index c27e38d16..3574f1e6d 100644 --- a/examples/reti/artifacts/ValidatorRegistry.approval.teal +++ b/examples/reti/artifacts/ValidatorRegistry.approval.teal @@ -530,7 +530,7 @@ getPools: *if0_end: // examples/reti/validatorRegistry.algo.ts:325 - // retData.push(poolSet[i]) + // retData.push(clone(poolSet[i])) frame_dig 0 // retData: PoolInfo[] frame_dig 1 // poolSet: (uint64,uint16,uint64)[24] frame_dig 2 // i: uint64 @@ -933,7 +933,7 @@ getStakedPoolsForAccount: // *if4_consequent // examples/reti/validatorRegistry.algo.ts:390 - // retData.push(poolSet[i]) + // retData.push(clone(poolSet[i])) frame_dig 0 // retData: ValidatorPoolKey[] frame_dig 1 // poolSet: (uint64,uint64,uint64)[6] frame_dig 2 // i: uint64 diff --git a/examples/reti/artifacts/ValidatorRegistry.arc32.json b/examples/reti/artifacts/ValidatorRegistry.arc32.json index e4ec2ab85..72c56f3f4 100644 --- a/examples/reti/artifacts/ValidatorRegistry.arc32.json +++ b/examples/reti/artifacts/ValidatorRegistry.arc32.json @@ -221,7 +221,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(poolSet[i])
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(poolSet[i])
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, poolKey)
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       poolKey,
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, poolKey)
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       poolKey,
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "contract": { diff --git a/examples/reti/artifacts/ValidatorRegistry.arc56.json b/examples/reti/artifacts/ValidatorRegistry.arc56.json index 43c21d527..d8c8f2220 100644 --- a/examples/reti/artifacts/ValidatorRegistry.arc56.json +++ b/examples/reti/artifacts/ValidatorRegistry.arc56.json @@ -28561,7 +28561,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(poolSet[i])
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(poolSet[i])
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, poolKey)
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       poolKey,
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, poolKey)
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       poolKey,
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "templateVariables": { diff --git a/examples/reti/stakingPool.algo.ts b/examples/reti/stakingPool.algo.ts index 948a9df34..c3d1ea739 100644 --- a/examples/reti/stakingPool.algo.ts +++ b/examples/reti/stakingPool.algo.ts @@ -434,7 +434,7 @@ export class StakingPool extends Contract { applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value), methodArgs: [ { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }, - staker, + clone(staker), 0, // no algo removed amountRewardTokenRemoved, false, // staker isn't being removed. diff --git a/examples/reti/validatorRegistry.algo.ts b/examples/reti/validatorRegistry.algo.ts index 6efab282f..fbb3421d3 100644 --- a/examples/reti/validatorRegistry.algo.ts +++ b/examples/reti/validatorRegistry.algo.ts @@ -322,7 +322,7 @@ export class ValidatorRegistry extends Contract { // reached end of list... we don't replace values here because pools can't be removed break; } - retData.push(poolSet[i]); + retData.push(clone(poolSet[i])); } return retData; } @@ -387,7 +387,7 @@ export class ValidatorRegistry extends Contract { const poolSet = clone(this.stakerPoolSet(staker).value); for (let i = 0; i < poolSet.length; i += 1) { if (poolSet[i].id !== 0) { - retData.push(poolSet[i]); + retData.push(clone(poolSet[i])); } } return retData; diff --git a/src/lib/compiler.ts b/src/lib/compiler.ts index c8b542031..8e0d559f9 100644 --- a/src/lib/compiler.ts +++ b/src/lib/compiler.ts @@ -14,6 +14,7 @@ import langspec from '../static/langspec.json'; import { VERSION } from '../version'; import { optimizeTeal } from './optimize'; import { type ARC56Contract, type StructField } from '../types/arc56.d'; +import { checkRefs } from './ref_checker'; const MULTI_OUTPUT_TYPES = ['split uint128', 'divmodw output', 'vrf return values', 'ecdsa pubkey']; @@ -116,6 +117,42 @@ type Event = { argTupleType: TypeInfo; }; +/** + * + * @param node The top level node to process + * @param chain The existing expression chain to add to + * @returns The base expression and reversed expression chain `this.txn.sender` -> + * `{ chain: [this.txn, this.txn.sender], base: [this] }` + */ +export function getExpressionChain( + node: ExpressionChainNode, + chain: ExpressionChainNode[] = [] +): { chain: ExpressionChainNode[]; base: ts.Node } { + chain.push(node); + + /** + * The expression on the given node + * `this.txn.sender` -> `this.txn` + */ + let expr: ts.Expression = node.getExpression(); + + /* this.txn.applicationArgs! -> this.txn.applicationArgs */ + if (expr.isKind(ts.SyntaxKind.NonNullExpression)) { + expr = expr.getExpression(); + } + + if ( + expr.isKind(ts.SyntaxKind.ElementAccessExpression) || + expr.isKind(ts.SyntaxKind.PropertyAccessExpression) || + expr.isKind(ts.SyntaxKind.CallExpression) + ) { + return getExpressionChain(expr, chain); + } + + chain.reverse(); + return { base: expr, chain }; +} + async function getSourceMap(vlqMappings: string) { const pcList = vlqMappings.split(';').map((m: string) => { const decoded = vlq.decode(m); @@ -1088,23 +1125,6 @@ export default class Compiler { */ private topLevelNode!: ts.Node; - private mutableRefCheck(e: ts.Node) { - const typeInfo = this.getTypeInfo(e.getType()); - if (typeInfo.kind !== 'base') { - if ( - !( - e.isKind(ts.SyntaxKind.CallExpression) || - e.isKind(ts.SyntaxKind.ArrayLiteralExpression) || - e.isKind(ts.SyntaxKind.ObjectLiteralExpression) - ) - ) { - throw Error( - `Cannot have multiple multiple references to the same object. Use clone to create a deep copy: clone(${e.getText()})` - ); - } - } - } - private getTypeInfo(type: ts.Type): TypeInfo { if (type.getText() === 'SplitUint128') return { kind: 'base', type: 'split uint128' }; if (type.getText() === 'DivmodwOutput') return { kind: 'base', type: 'divmodw output' }; @@ -2056,8 +2076,6 @@ export default class Compiler { if (!this.isDynamicArrayOfStaticType(this.lastType)) throw new Error('Cannot push to dynamic array of dynamic types'); - this.mutableRefCheck(node.getArguments()[0]); - this.processNode(node.getArguments()[0]); this.checkEncoding(node.getArguments()[0], this.lastType); this.pushVoid(node, 'concat'); @@ -2857,6 +2875,10 @@ export default class Compiler { // Go over all the files we are importing and check for number keywords [sourceFile, ...importedFiles].forEach((f) => { + if (f === undefined) return; + + checkRefs(f, path.relative(this.cwd, f.getFilePath())); + f?.getStatements().forEach((s) => { const numberKeywords = s.getDescendantsOfKind(ts.SyntaxKind.NumberKeyword); @@ -3655,10 +3677,6 @@ export default class Compiler { const { typeHint } = this; if (typeHint === undefined) throw Error('Type hint must be provided to process object or array'); - elements.forEach((e) => { - this.mutableRefCheck(e); - }); - if ( typeHint.kind === 'tuple' || typeHint.kind === 'object' || @@ -3720,42 +3738,6 @@ export default class Compiler { this.processArrayElements(node.getElements(), node); } - /** - * - * @param node The top level node to process - * @param chain The existing expression chain to add to - * @returns The base expression and reversed expression chain `this.txn.sender` -> - * `{ chain: [this.txn, this.txn.sender], base: [this] }` - */ - private getExpressionChain( - node: ExpressionChainNode, - chain: ExpressionChainNode[] = [] - ): { chain: ExpressionChainNode[]; base: ts.Node } { - chain.push(node); - - /** - * The expression on the given node - * `this.txn.sender` -> `this.txn` - */ - let expr: ts.Expression = node.getExpression(); - - /* this.txn.applicationArgs! -> this.txn.applicationArgs */ - if (expr.isKind(ts.SyntaxKind.NonNullExpression)) { - expr = expr.getExpression(); - } - - if ( - expr.isKind(ts.SyntaxKind.ElementAccessExpression) || - expr.isKind(ts.SyntaxKind.PropertyAccessExpression) || - expr.isKind(ts.SyntaxKind.CallExpression) - ) { - return this.getExpressionChain(expr, chain); - } - - chain.reverse(); - return { base: expr, chain }; - } - private getAccessChain(node: ts.ElementAccessExpression, chain: ts.ElementAccessExpression[] = []) { chain.push(node); @@ -4250,8 +4232,6 @@ export default class Compiler { !this.isDynamicType(this.storageProps[getStorageName(storageExpression)!].valueType); if (newValue) { - this.mutableRefCheck(newValue); - if (newValue.getType().isNumberLiteral()) { this.processNewValue(newValue, elem.type); } else { @@ -4362,8 +4342,6 @@ export default class Compiler { } if (newValue) { - this.mutableRefCheck(newValue); - if (this.isDynamicType(element.type)) { if (element.parent?.arrayType !== 'tuple') { throw new Error( @@ -6344,7 +6322,7 @@ export default class Compiler { } } - const { base, chain } = this.getExpressionChain(node); + const { base, chain } = getExpressionChain(node); if (base.isKind(ts.SyntaxKind.ParenthesizedExpression)) { if (!base.getExpression().isKind(ts.SyntaxKind.BinaryExpression)) diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts new file mode 100644 index 000000000..50637fa6b --- /dev/null +++ b/src/lib/ref_checker.ts @@ -0,0 +1,172 @@ +import * as ts from 'ts-morph'; +import path from 'path'; +import { getExpressionChain } from './compiler'; + +/** Expressions that access (read or write) the array */ +function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { + const elementExpr = methodBody.getDescendantsOfKind(ts.SyntaxKind.ElementAccessExpression); + const propExpr = methodBody.getDescendantsOfKind(ts.SyntaxKind.PropertyAccessExpression); + + const nodes: ts.Node[] = []; + [...elementExpr, ...propExpr].forEach((n) => { + const chain = getExpressionChain(n); + + [chain.base, ...chain.chain].forEach((e) => { + if (e.getText() === node.getText() && e.getPos() !== node.getPos()) { + nodes.push(e); + } + }); + }); + + return nodes; +} + +/** References to the node created in an array literal expression */ +function referencesInArrayLiteral(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.ArrayLiteralExpression).forEach((n) => { + n.getElements().forEach((e) => { + if (e.getText() === node.getText() && e !== node) { + nodes.push(e); + } + }); + }); + + return nodes; +} + +/** References to the node created in an object literal expression */ +function referencesInObjectLiteral(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.ObjectLiteralExpression).forEach((n) => { + n.getProperties().forEach((e) => { + // TODO: Support short-hand + if (!e.isKind(ts.SyntaxKind.PropertyAssignment)) throw new Error(); + const value = e.getInitializer(); + if (value?.getText() === node.getText() && value !== node) { + nodes.push(value); + } + }); + }); + + return nodes; +} + +const AVM_OBJECT_TYPES = ['Address', 'AppID', 'AssetID']; + +/** References to the node created by a variable declaration */ +function referencesInVariableDeclaration(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { + const val = n.getInitializer(); + const valType = val?.getType(); + + if (!valType?.isArray() && !valType?.isObject()) { + return; + } + + if (val?.getText() === node.getText() && val !== node) { + nodes.push(val); + } + }); + + return nodes; +} + +function getNodeLines(node: ts.Node, pathStr: string) { + const refFullLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1].trim(); + + return `${pathStr}:${node.getStartLineNumber()}:\n ${refFullLine}`; +} + +function isCloned(node: ts.Node) { + const callParent = node.getParentIfKind(ts.SyntaxKind.CallExpression); + const expr = callParent?.getExpressionIfKind(ts.SyntaxKind.Identifier); + return callParent && expr?.getText() === 'clone'; +} + +export function checkRefs(file: ts.SourceFile, pathStr: string) { + file.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration).forEach((m) => { + const body = m.getBody()!; + const mutableValues = [ + // TODO: We get variables from declaration, but also need to support destructuring + ...body.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).map((v) => v.getNameNode()), + ...body.getDescendantsOfKind(ts.SyntaxKind.PropertyAccessExpression), + ...body.getDescendantsOfKind(ts.SyntaxKind.ElementAccessExpression), + ] + .filter((n) => n.getType().isArray() || n.getType().isObject()) + .filter((n) => { + if (n.isKind(ts.SyntaxKind.Identifier)) { + const callParent = n.getFirstAncestorByKind(ts.SyntaxKind.CallExpression); + const expr = callParent?.getExpression(); + + // filter out function names in property access expressions + if (expr?.isKind(ts.SyntaxKind.PropertyAccessExpression)) { + return expr.getNameNode() !== n; + } + + // filter out function names + if (expr?.isKind(ts.SyntaxKind.Identifier)) { + return expr !== n; + } + } + + // filter out function calls on property access expressions + if (n.isKind(ts.SyntaxKind.PropertyAccessExpression)) { + const callParent = n.getFirstAncestorByKind(ts.SyntaxKind.CallExpression); + const expr = callParent?.getExpression(); + + return expr !== n; + } + + return true; + }); + + mutableValues.forEach((n) => { + const accessNodes = arrayOrObjAccess(n, body); + + accessNodes.forEach((a) => { + if ( + a.getParentIfKind(ts.SyntaxKind.CallExpression) && + !isCloned(a) && + !AVM_OBJECT_TYPES.includes(a.getType().getText()) + ) { + throw Error( + `Cannot pass reference to a function. Use clone to create a deep copy: clone(${n.getText()})\n${getNodeLines( + a, + pathStr + )}` + ); + } + }); + + const referenceNodes = [ + ...referencesInArrayLiteral(n, body), + ...referencesInObjectLiteral(n, body), + ...referencesInVariableDeclaration(n, body), + ].filter((r) => !AVM_OBJECT_TYPES.includes(r.getType().getText())); + + referenceNodes.forEach((ref) => { + const violator = [...referenceNodes, ...accessNodes].find((v) => v.getPos() > ref.getPos()); + + if (violator !== undefined) { + const refLines = `Initial reference at ${getNodeLines(ref, pathStr)}`; + const violatorIsReference = referenceNodes.includes(violator); + const violatorLines = `${violatorIsReference ? 'Second reference' : 'Access'} at ${getNodeLines( + violator, + pathStr + )}`; + + throw new Error( + `Cannot access or create a reference to an mutable type (${n + .getType() + .getText()}) that already has multiple references. You might want to use "clone" to create a deep copy instead of creating a reference to the same array: clone(${ref.getText()}).\n\n${refLines}\n${violatorLines}` + ); + } + }); + }); + }); +} From 93747275c77024a63c3f1a65109e8d5ec4ad9740 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 9 Apr 2025 15:03:49 -0400 Subject: [PATCH 03/29] wip: fix eslint --- src/lib/compiler.ts | 39 +-------------------------------------- src/lib/ref_checker.ts | 3 +-- src/lib/utils.ts | 39 +++++++++++++++++++++++++++++++++++++++ tests/references.test.ts | 9 ++------- 4 files changed, 43 insertions(+), 47 deletions(-) create mode 100644 src/lib/utils.ts diff --git a/src/lib/compiler.ts b/src/lib/compiler.ts index 8e0d559f9..d223ba97b 100644 --- a/src/lib/compiler.ts +++ b/src/lib/compiler.ts @@ -15,11 +15,10 @@ import { VERSION } from '../version'; import { optimizeTeal } from './optimize'; import { type ARC56Contract, type StructField } from '../types/arc56.d'; import { checkRefs } from './ref_checker'; +import { getExpressionChain, ExpressionChainNode } from './utils'; const MULTI_OUTPUT_TYPES = ['split uint128', 'divmodw output', 'vrf return values', 'ecdsa pubkey']; -type ExpressionChainNode = ts.ElementAccessExpression | ts.PropertyAccessExpression | ts.CallExpression; - type OnComplete = 'NoOp' | 'OptIn' | 'CloseOut' | 'ClearState' | 'UpdateApplication' | 'DeleteApplication'; const ON_COMPLETES: ['NoOp', 'OptIn', 'CloseOut', 'ClearState', 'UpdateApplication', 'DeleteApplication'] = [ 'NoOp', @@ -117,42 +116,6 @@ type Event = { argTupleType: TypeInfo; }; -/** - * - * @param node The top level node to process - * @param chain The existing expression chain to add to - * @returns The base expression and reversed expression chain `this.txn.sender` -> - * `{ chain: [this.txn, this.txn.sender], base: [this] }` - */ -export function getExpressionChain( - node: ExpressionChainNode, - chain: ExpressionChainNode[] = [] -): { chain: ExpressionChainNode[]; base: ts.Node } { - chain.push(node); - - /** - * The expression on the given node - * `this.txn.sender` -> `this.txn` - */ - let expr: ts.Expression = node.getExpression(); - - /* this.txn.applicationArgs! -> this.txn.applicationArgs */ - if (expr.isKind(ts.SyntaxKind.NonNullExpression)) { - expr = expr.getExpression(); - } - - if ( - expr.isKind(ts.SyntaxKind.ElementAccessExpression) || - expr.isKind(ts.SyntaxKind.PropertyAccessExpression) || - expr.isKind(ts.SyntaxKind.CallExpression) - ) { - return getExpressionChain(expr, chain); - } - - chain.reverse(); - return { base: expr, chain }; -} - async function getSourceMap(vlqMappings: string) { const pcList = vlqMappings.split(';').map((m: string) => { const decoded = vlq.decode(m); diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 50637fa6b..2c9f9afa5 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -1,6 +1,5 @@ import * as ts from 'ts-morph'; -import path from 'path'; -import { getExpressionChain } from './compiler'; +import { getExpressionChain } from './utils'; /** Expressions that access (read or write) the array */ function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { diff --git a/src/lib/utils.ts b/src/lib/utils.ts new file mode 100644 index 000000000..c9cf2cd58 --- /dev/null +++ b/src/lib/utils.ts @@ -0,0 +1,39 @@ +import * as ts from 'ts-morph'; + +export type ExpressionChainNode = ts.ElementAccessExpression | ts.PropertyAccessExpression | ts.CallExpression; + +/** + * + * @param node The top level node to process + * @param chain The existing expression chain to add to + * @returns The base expression and reversed expression chain `this.txn.sender` -> + * `{ chain: [this.txn, this.txn.sender], base: [this] }` + */ +export function getExpressionChain( + node: ExpressionChainNode, + chain: ExpressionChainNode[] = [] +): { chain: ExpressionChainNode[]; base: ts.Node } { + chain.push(node); + + /** + * The expression on the given node + * `this.txn.sender` -> `this.txn` + */ + let expr: ts.Expression = node.getExpression(); + + /* this.txn.applicationArgs! -> this.txn.applicationArgs */ + if (expr.isKind(ts.SyntaxKind.NonNullExpression)) { + expr = expr.getExpression(); + } + + if ( + expr.isKind(ts.SyntaxKind.ElementAccessExpression) || + expr.isKind(ts.SyntaxKind.PropertyAccessExpression) || + expr.isKind(ts.SyntaxKind.CallExpression) + ) { + return getExpressionChain(expr, chain); + } + + chain.reverse(); + return { base: expr, chain }; +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 095a886db..2cb3229dd 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -1,11 +1,6 @@ -import { describe, test, expect, beforeAll } from '@jest/globals'; -import * as algokit from '@algorandfoundation/algokit-utils'; -import path from 'path'; -// eslint-disable-next-line import/no-unresolved -import { ApplicationClient } from '@algorandfoundation/algokit-utils/types/app-client'; +import { describe, test, expect } from '@jest/globals'; import algosdk from 'algosdk'; -import { getMethodTeal, artifactsTest, algodClient, kmdClient, compileAndCreate, TESTS_PROJECT } from './common'; -import Compiler from '../src/lib/compiler'; +import { compileAndCreate } from './common'; const ARTIFACTS_DIR = 'tests/contracts/artifacts/'; From cb725c9a73da2d19aa2e5dad96b261752e8982c2 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 9 Apr 2025 15:05:58 -0400 Subject: [PATCH 04/29] wip: fix ref test --- tests/references.test.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/references.test.ts b/tests/references.test.ts index 2cb3229dd..4cad9fae7 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -25,9 +25,9 @@ function compilerErrorTest(contractName: string, errorMsg: string) { } describe('Reference Compile Errors', () => { - compilerErrorTest('MutableRefInObjLiteral', 'Cannot have multiple multiple references to the same object'); - compilerErrorTest('MutableRefInObjAssignment', 'Cannot have multiple multiple references to the same object'); - compilerErrorTest('MutableRefInArrayLiteral', 'Cannot have multiple multiple references to the same object'); - compilerErrorTest('MutableRefInArrayAssignment', 'Cannot have multiple multiple references to the same object'); - compilerErrorTest('MutableRefInPush', 'Cannot push to dynamic array of dynamic types'); + compilerErrorTest('MutableRefInObjLiteral', 'Cannot access or create a reference to an mutable type'); + compilerErrorTest('MutableRefInObjAssignment', 'Cannot access or create a reference to an mutable type'); + compilerErrorTest('MutableRefInArrayLiteral', 'Cannot access or create a reference to an mutable type'); + compilerErrorTest('MutableRefInArrayAssignment', 'Cannot access or create a reference to an mutable type'); + compilerErrorTest('MutableRefInPush', 'Cannot access or create a reference to an mutable type'); }); From 079357d1bbde59af837c53f3c3937ce74562c46d Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Fri, 11 Apr 2025 15:27:30 -0400 Subject: [PATCH 05/29] wip: rm extra clone on Address --- examples/reti/artifacts/StakingPool.approval.teal | 4 ++-- examples/reti/artifacts/StakingPool.arc32.json | 2 +- examples/reti/artifacts/StakingPool.arc56.json | 2 +- examples/reti/stakingPool.algo.ts | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/reti/artifacts/StakingPool.approval.teal b/examples/reti/artifacts/StakingPool.approval.teal index f3558091c..9c6555881 100644 --- a/examples/reti/artifacts/StakingPool.approval.teal +++ b/examples/reti/artifacts/StakingPool.approval.teal @@ -1668,7 +1668,7 @@ claimTokens: // applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value), // methodArgs: [ // { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }, - // clone(staker), + // staker, // 0, // no algo removed // amountRewardTokenRemoved, // false, // staker isn't being removed. @@ -1689,7 +1689,7 @@ claimTokens: // examples/reti/stakingPool.algo.ts:435 // methodArgs: [ // { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }, - // clone(staker), + // staker, // 0, // no algo removed // amountRewardTokenRemoved, // false, // staker isn't being removed. diff --git a/examples/reti/artifacts/StakingPool.arc32.json b/examples/reti/artifacts/StakingPool.arc32.json index 45c38f522..e02810f5d 100644 --- a/examples/reti/artifacts/StakingPool.arc32.json +++ b/examples/reti/artifacts/StakingPool.arc32.json @@ -161,7 +161,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "contract": { diff --git a/examples/reti/artifacts/StakingPool.arc56.json b/examples/reti/artifacts/StakingPool.arc56.json index 33a6e27df..eeb512929 100644 --- a/examples/reti/artifacts/StakingPool.arc56.json +++ b/examples/reti/artifacts/StakingPool.arc56.json @@ -19064,7 +19064,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             clone(staker),
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 6 64 32 16 128 200 5 300 1000 4 1_000_000 2_100_000 8 100000 400 2 40 48 TMPL_nfdRegistryAppId
bytecblock 0x 0x63726561746f72417070 0x7374616b657273 0x76616c696461746f724964 0x706f6f6c4964 0x0a8101 0x7374616b6564 0x7374616b65416363756d756c61746f72 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 0x0000000000000000 0x726f756e6473506572446179 0x62696e526f756e645374617274 0x726577617264416363756d756c61746f72 0x6e756d5374616b657273 0x6c6173745061796f7574 0x75aff61d 0x00000000000000000000000000000000 0x00000000000000000000000000000064 0x6d696e456e7472795374616b65 0x65706f63684e756d626572 0x65776d61 0x151f7c75 0xa2dc51b5 0x572767d1 0x4df8d86e 0x0c2245e1 0x00 TMPL_feeSinkAddr

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 2 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:94
	// assert(
	//       this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'),
	//       'Temporary: contract is upgradeable but only during testing and only from a development account'
	//     )
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==

	// Temporary: contract is upgradeable but only during testing and only from a development account
	assert
	retsub

// createApplication(uint64,uint64,uint64,uint64)void
*abi_route_createApplication:
	// minEntryStake: uint64
	txna ApplicationArgs 4
	btoi

	// poolId: uint64
	txna ApplicationArgs 3
	btoi

	// validatorId: uint64
	txna ApplicationArgs 2
	btoi

	// creatingContractId: uint64
	txna ApplicationArgs 1
	btoi

	// execute createApplication(uint64,uint64,uint64,uint64)void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(creatingContractId: uint64, validatorId: uint64, poolId: uint64, minEntryStake: uint64): void
//
// Initialize the staking pool w/ owner and manager, but can only be created by the validator contract.
// @param {uint64} creatingContractId - id of contract that constructed us - the validator application (single global instance)
// @param {uint64} validatorId - id of validator we're a staking pool of
// @param {uint64} poolId - which pool id are we
// @param {uint64} minEntryStake - minimum amount to be in pool, but also minimum amount balance can't go below (without removing all!)
createApplication:
	proto 4 0

	// *if0_condition
	// examples/reti/stakingPool.algo.ts:108
	// creatingContractId === 0
	frame_dig -1 // creatingContractId: uint64
	intc 0 // 0
	==
	bz *if0_else

	// *if0_consequent
	// examples/reti/stakingPool.algo.ts:110
	// assert(validatorId === 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	==
	assert

	// examples/reti/stakingPool.algo.ts:111
	// assert(poolId === 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	==
	assert
	b *if0_end

*if0_else:
	// examples/reti/stakingPool.algo.ts:113
	// assert(validatorId !== 0)
	frame_dig -2 // validatorId: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/stakingPool.algo.ts:114
	// assert(poolId !== 0)
	frame_dig -3 // poolId: uint64
	intc 0 // 0
	!=
	assert

*if0_end:
	// examples/reti/stakingPool.algo.ts:116
	// assert(minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -4 // minEntryStake: uint64
	pushint 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/stakingPool.algo.ts:117
	// this.creatingValidatorContractAppId.value = creatingContractId
	bytec 1 //  "creatorApp"
	frame_dig -1 // creatingContractId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:118
	// this.validatorId.value = validatorId
	bytec 3 //  "validatorId"
	frame_dig -2 // validatorId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:119
	// this.poolId.value = poolId
	bytec 4 //  "poolId"
	frame_dig -3 // poolId: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:120
	// this.numStakers.value = 0
	bytec 13 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:121
	// this.totalAlgoStaked.value = 0
	bytec 6 //  "staked"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:122
	// this.minEntryStake.value = minEntryStake
	bytec 18 //  "minEntryStake"
	frame_dig -4 // minEntryStake: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:123
	// this.lastPayout.value = globals.round
	bytec 14 //  "lastPayout"
	global Round
	app_global_put

	// examples/reti/stakingPool.algo.ts:124
	// this.epochNumber.value = 0
	bytec 19 //  "epochNumber"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:126
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:127
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

	// examples/reti/stakingPool.algo.ts:128
	// this.stakeAccumulator.value = 0 as uint128
	bytec 7 //  "stakeAccumulator"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put

	// examples/reti/stakingPool.algo.ts:129
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:130
	// this.weightedMovingAverage.value = 0 as uint128
	bytec 20 //  "ewma"
	bytec 16 // 0x00000000000000000000000000000000
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/stakingPool.algo.ts:142
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	intc 16 // 400
	*
	+
	retsub

// initStorage(pay)void
*abi_route_initStorage:
	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 0 (mbrPayment) for initStorage must be a pay transaction
	assert

	// execute initStorage(pay)void
	callsub initStorage
	intc 1 // 1
	return

// initStorage(mbrPayment: PayTxn): void
//
// Called after we're created and then funded, so we can create our large stakers ledger storage
// Caller has to get MBR amounts from ValidatorRegistry to know how much to fund us to cover the box storage cost
// If this is pool 1 AND the validator has specified a reward token, opt-in to that token
// so that the validator can seed the pool with future rewards of that token.
// @param mbrPayment payment from caller which covers mbr increase of new staking pools' storage
initStorage:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 3

	// examples/reti/stakingPool.algo.ts:153
	// assert(!this.stakers.exists, 'staking pool already initialized')
	bytec 2 //  "stakers"
	box_len
	swap
	pop
	!

	// staking pool already initialized
	assert

	// examples/reti/stakingPool.algo.ts:156
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:157
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:158
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:160
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 1 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:161
	// extraMBR = isTokenEligible && this.poolId.value === 1 ? ASSET_HOLDING_FEE : 0
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and0:
	bz *ternary0_false
	intc 15 // 100000
	b *ternary0_end

*ternary0_false:
	intc 0 // 0

*ternary0_end:
	frame_bury 2 // extraMBR: uint64

	// examples/reti/stakingPool.algo.ts:162
	// PoolInitMbr =
	//       ALGORAND_ACCOUNT_MIN_BALANCE +
	//       extraMBR +
	//       this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL)
	intc 15 // 100000
	frame_dig 2 // extraMBR: uint64
	+
	pushint 12807
	callsub costForBoxStorage
	+
	frame_bury 3 // PoolInitMbr: uint64

	// examples/reti/stakingPool.algo.ts:168
	// verifyPayTxn(mbrPayment, { receiver: this.app.address, amount: PoolInitMbr })
	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	frame_dig 3 // PoolInitMbr: uint64
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"PoolInitMbr"}
	assert

	// examples/reti/stakingPool.algo.ts:169
	// this.stakers.create()
	bytec 2 //  "stakers"
	pushint 12800
	box_create
	pop

	// *if1_condition
	// examples/reti/stakingPool.algo.ts:171
	// isTokenEligible && this.poolId.value === 1
	frame_dig 1 // isTokenEligible: bool
	dup
	bz *skip_and1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	&&

*skip_and1:
	bz *if1_end

	// *if1_consequent
	// examples/reti/stakingPool.algo.ts:173
	// sendAssetTransfer({
	//         xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//         assetReceiver: this.app.address,
	//         assetAmount: 0,
	//       })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:174
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:175
	// assetReceiver: this.app.address
	global CurrentApplicationAddress
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:176
	// assetAmount: 0
	intc 0 // 0
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if1_end:
	retsub

// addStake(pay,address)uint64
*abi_route_addStake:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for addStake must be a address
	assert

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 1 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,address)uint64
	callsub addStake
	itob
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, staker: Address): uint64
//
// Adds stake to the given account.
// Can ONLY be called by the validator contract that created us
// Must receive payment from the validator contract for amount being staked.
//
// @param {PayTxn} stakedAmountPayment prior payment coming from validator contract to us on behalf of staker.
// @param {Address} staker - The account adding new stake
// @throws {Error} - Throws an error if the staking pool is full.
// @returns {uint64} new 'entry round' round number of stake add
addStake:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:192
	// assert(this.stakers.exists, 'staking pool must be initialized first')
	bytec 2 //  "stakers"
	box_len
	swap
	pop

	// staking pool must be initialized first
	assert

	// examples/reti/stakingPool.algo.ts:195
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'stake can only be added via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// stake can only be added via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:199
	// assert(staker !== globals.zeroAddress)
	frame_dig -2 // staker: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/stakingPool.algo.ts:202
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:206
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       receiver: this.app.address,
	//       amount: stakedAmountPayment.amount,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"AppID.fromUint64(this.creatingValidatorContractAppId.value).address"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"amount","expected":"stakedAmountPayment.amount"}
	assert

	// examples/reti/stakingPool.algo.ts:215
	// entryRound = globals.round + ALGORAND_STAKING_BLOCK_DELAY
	global Round
	pushint 320
	+
	frame_bury 0 // entryRound: uint64

	// examples/reti/stakingPool.algo.ts:216
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/stakingPool.algo.ts:218
	// this.totalAlgoStaked.value += stakedAmountPayment.amount
	bytec 6 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:220
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 2 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:221
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	frame_dig 2 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (stakedAmountPayment.amount as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:225
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 3 // i: uint64

*for_0:
	// examples/reti/stakingPool.algo.ts:225
	// i < this.stakers.value.length
	frame_dig 3 // i: uint64
	intc 7 // 200
	<
	bz *for_0_end

	// *if2_condition
	// examples/reti/stakingPool.algo.ts:226
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/stakingPool.algo.ts:227
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if2_end:
	// examples/reti/stakingPool.algo.ts:229
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if3_condition
	// examples/reti/stakingPool.algo.ts:230
	// cmpStaker.account === staker
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -2 // staker: Address
	==
	bz *if3_end

	// *if3_consequent
	// examples/reti/stakingPool.algo.ts:232
	// cmpStaker.balance += stakedAmountPayment.amount
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	+
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:233
	// cmpStaker.entryRound = entryRound
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	pushint 56 // headOffset
	frame_dig 0 // entryRound: uint64
	itob
	replace3
	frame_bury 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:236
	// this.stakers.value[i] = cmpStaker
	frame_dig 3 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:238
	// return entryRound;
	frame_dig 0 // entryRound: uint64
	b *addStake*return

*if3_end:
	// *if4_condition
	// examples/reti/stakingPool.algo.ts:240
	// firstEmpty === 0 && cmpStaker.account === globals.zeroAddress
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and2
	frame_dig 4 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	==
	&&

*skip_and2:
	bz *if4_end

	// *if4_consequent
	// examples/reti/stakingPool.algo.ts:241
	// firstEmpty = i + 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if4_end:

*for_0_continue:
	// examples/reti/stakingPool.algo.ts:225
	// i += 1
	frame_dig 3 // i: uint64
	intc 1 // 1
	+
	frame_bury 3 // i: uint64
	b *for_0

*for_0_end:
	// *if5_condition
	// examples/reti/stakingPool.algo.ts:245
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if5_end

	// *if5_consequent
	// Staking pool full
	err

*if5_end:
	// examples/reti/stakingPool.algo.ts:252
	// assert(stakedAmountPayment.amount >= this.minEntryStake.value, 'must stake at least the minimum for this pool')
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	bytec 18 //  "minEntryStake"
	app_global_get
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/stakingPool.algo.ts:254
	// assert(this.stakers.value[firstEmpty - 1].account === globals.zeroAddress)
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	global ZeroAddress
	==
	assert

	// examples/reti/stakingPool.algo.ts:255
	// this.stakers.value[firstEmpty - 1] = {
	//       account: staker,
	//       balance: stakedAmountPayment.amount,
	//       totalRewarded: 0,
	//       rewardTokenBalance: 0,
	//       entryRound: entryRound,
	//     }
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 64
	* // acc * typeLength
	frame_dig -2 // staker: Address
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	itob
	concat
	bytec 9 // 0x0000000000000000
	concat
	bytec 9 // 0x0000000000000000
	concat
	frame_dig 0 // entryRound: uint64
	itob
	concat
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:262
	// this.numStakers.value += 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:263
	// return entryRound;
	frame_dig 0 // entryRound: uint64

*addStake*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// removeStake(address,uint64)void
*abi_route_removeStake:
	// amountToUnstake: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for removeStake must be a address
	assert

	// execute removeStake(address,uint64)void
	callsub removeStake
	intc 1 // 1
	return

// removeStake(staker: Address, amountToUnstake: uint64): void
//
// Removes stake on behalf of caller (removing own stake).  If any token rewards exist, those are always sent in
// full. Also notifies the validator contract for this pools validator of the staker / balance changes.
//
// @param {Address} staker - account to remove.  normally same as sender, but the validator owner or manager can also call
// this to remove the specified staker explicitly. The removed stake MUST only go to the staker of course.  This is
// so a validator can shut down a poool and refund the stakers.  It can also be used to kick out stakers who no longer
// meet the gating requirements (determined by the node daemon).
// @param {uint64} amountToUnstake - The amount of stake to be removed.  Specify 0 to remove all stake.
// @throws {Error} If the account has insufficient balance or if the account is not found.
removeStake:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 6

	// *if6_condition
	// examples/reti/stakingPool.algo.ts:280
	// staker !== this.txn.sender
	frame_dig -1 // staker: Address
	txn Sender
	!=
	bz *if6_end

	// *if6_consequent
	// examples/reti/stakingPool.algo.ts:281
	// assert(
	//         this.isOwnerOrManagerCaller(),
	//         'If staker is not sender in removeStake call, then sender MUST be owner or manager of validator'
	//       )
	callsub isOwnerOrManagerCaller

	// If staker is not sender in removeStake call, then sender MUST be owner or manager of validator
	assert

*if6_end:
	// examples/reti/stakingPool.algo.ts:287
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:289
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_1:
	// examples/reti/stakingPool.algo.ts:289
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_1_end

	// *if7_condition
	// examples/reti/stakingPool.algo.ts:290
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if7_end

	// *if7_consequent
	// examples/reti/stakingPool.algo.ts:291
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if7_end:
	// examples/reti/stakingPool.algo.ts:293
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if8_condition
	// examples/reti/stakingPool.algo.ts:294
	// cmpStaker.account === staker
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig -1 // staker: Address
	==
	bz *if8_end

	// *if8_consequent
	// *if9_condition
	// examples/reti/stakingPool.algo.ts:295
	// amountToUnstake === 0
	frame_dig -2 // amountToUnstake: uint64
	intc 0 // 0
	==
	bz *if9_end

	// *if9_consequent
	// examples/reti/stakingPool.algo.ts:297
	// amountToUnstake = cmpStaker.balance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_bury -2 // amountToUnstake: uint64

*if9_end:
	// *if10_condition
	// examples/reti/stakingPool.algo.ts:299
	// cmpStaker.balance < amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	<
	bz *if10_end

	// *if10_consequent
	// Insufficient balance
	err

*if10_end:
	// examples/reti/stakingPool.algo.ts:302
	// cmpStaker.balance -= amountToUnstake
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig -2 // amountToUnstake: uint64
	-
	itob
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:303
	// this.totalAlgoStaked.value -= amountToUnstake
	bytec 6 //  "staked"
	app_global_get
	frame_dig -2 // amountToUnstake: uint64
	-
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:305
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// *if11_condition
	// examples/reti/stakingPool.algo.ts:306
	// cmpStaker.rewardTokenBalance > 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	>
	bz *if11_end

	// *if11_consequent
	// *if12_condition
	// examples/reti/stakingPool.algo.ts:308
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if12_else

	// *if12_consequent
	// examples/reti/stakingPool.algo.ts:309
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//               applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//               methodArgs: [this.validatorId.value],
	//             })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:310
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:311
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:317
	// sendAssetTransfer({
	//               xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//               assetReceiver: staker,
	//               assetAmount: cmpStaker.rewardTokenBalance,
	//             })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:318
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 3 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:319
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:320
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:322
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:323
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if12_end

*if12_else:
	// examples/reti/stakingPool.algo.ts:328
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 2 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:329
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if12_end:

*if11_end:
	// examples/reti/stakingPool.algo.ts:334
	// assert(
	//           cmpStaker.balance === 0 || cmpStaker.balance >= this.minEntryStake.value,
	//           'cannot reduce balance below minimum allowed stake unless all is removed'
	//         )
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	dup
	bnz *skip_or0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	bytec 18 //  "minEntryStake"
	app_global_get
	>=
	||

*skip_or0:
	// cannot reduce balance below minimum allowed stake unless all is removed
	assert

	// examples/reti/stakingPool.algo.ts:342
	// sendPayment({
	//           amount: amountToUnstake,
	//           receiver: staker,
	//           note: 'unstaked',
	//         })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:343
	// amount: amountToUnstake
	frame_dig -2 // amountToUnstake: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:344
	// receiver: staker
	frame_dig -1 // staker: Address
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:345
	// note: 'unstaked'
	pushbytes 0x756e7374616b6564 // "unstaked"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:347
	// stakerRemoved = false
	intc 0 // 0
	frame_bury 4 // stakerRemoved: bool

	// *if13_condition
	// examples/reti/stakingPool.algo.ts:348
	// cmpStaker.balance === 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	intc 0 // 0
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/stakingPool.algo.ts:350
	// this.numStakers.value -= 1
	bytec 13 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 13 //  "numStakers"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:351
	// cmpStaker.account = globals.zeroAddress
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 0 // 0
	global ZeroAddress
	replace3
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:352
	// cmpStaker.totalRewarded = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 40
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:353
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:354
	// stakerRemoved = true
	intc 1 // 1
	frame_bury 4 // stakerRemoved: bool

*if13_end:
	// examples/reti/stakingPool.algo.ts:357
	// this.stakers.value[i] = cmpStaker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 1 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:359
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 5 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:360
	// subtractAmount: uint128 = (amountToUnstake as uint128) * (roundsLeftInBin as uint128)
	frame_dig -2 // amountToUnstake: uint64
	itob
	frame_dig 5 // roundsLeftInBin: uint64
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (amountToUnstake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 6 // subtractAmount: uint128

	// examples/reti/stakingPool.algo.ts:361
	// this.stakeAccumulator.value = this.stakeAccumulator.value - subtractAmount
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 6 // subtractAmount: uint128
	b-
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value - subtractAmount overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:366
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:367
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:368
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             amountToUnstake,
	//             amountRewardTokenRemoved,
	//             stakerRemoved,
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig -1 // staker: Address
	itxn_field ApplicationArgs
	frame_dig -2 // amountToUnstake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 2 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 4 // stakerRemoved: bool
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:376
	// return;
	retsub

*if8_end:

*for_1_continue:
	// examples/reti/stakingPool.algo.ts:289
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_1

*for_1_end:
	// account not found
	err
	retsub

// claimTokens()void
*abi_route_claimTokens:
	// execute claimTokens()void
	callsub claimTokens
	intc 1 // 1
	return

// claimTokens(): void
//
// Claims all the available reward tokens a staker has available, sending their entire balance to the staker from
// pool 1 (either directly, or via validator->pool1 to pay it out)
// Also notifies the validator contract for this pools validator of the staker / balance changes.
claimTokens:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:391
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/stakingPool.algo.ts:393
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_2:
	// examples/reti/stakingPool.algo.ts:393
	// i < this.stakers.value.length
	frame_dig 1 // i: uint64
	intc 7 // 200
	<
	bz *for_2_end

	// *if14_condition
	// examples/reti/stakingPool.algo.ts:394
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if14_end

	// *if14_consequent
	// examples/reti/stakingPool.algo.ts:395
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if14_end:
	// examples/reti/stakingPool.algo.ts:397
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if15_condition
	// examples/reti/stakingPool.algo.ts:398
	// cmpStaker.account === staker
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	frame_dig 0 // staker: address
	==
	bz *if15_end

	// *if15_consequent
	// *if16_condition
	// examples/reti/stakingPool.algo.ts:399
	// cmpStaker.rewardTokenBalance === 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	intc 0 // 0
	==
	bz *if16_end

	// *if16_consequent
	// examples/reti/stakingPool.algo.ts:400
	// return;
	retsub

*if16_end:
	// examples/reti/stakingPool.algo.ts:402
	// amountRewardTokenRemoved = 0
	intc 0 // 0
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// *if17_condition
	// examples/reti/stakingPool.algo.ts:404
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if17_else

	// *if17_consequent
	// examples/reti/stakingPool.algo.ts:405
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//             applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//             methodArgs: [this.validatorId.value],
	//           })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:406
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:407
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:412
	// sendAssetTransfer({
	//             xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId),
	//             assetReceiver: staker,
	//             assetAmount: cmpStaker.rewardTokenBalance,
	//           })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:413
	// xferAsset: AssetID.fromUint64(validatorConfig.rewardTokenId)
	frame_dig 4 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:414
	// assetReceiver: staker
	frame_dig 0 // staker: address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:415
	// assetAmount: cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:417
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:418
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	b *if17_end

*if17_else:
	// examples/reti/stakingPool.algo.ts:423
	// amountRewardTokenRemoved = cmpStaker.rewardTokenBalance
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_bury 3 // amountRewardTokenRemoved: uint64

	// examples/reti/stakingPool.algo.ts:424
	// cmpStaker.rewardTokenBalance = 0
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 9 // 0x0000000000000000
	replace2 48
	frame_bury 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)

*if17_end:
	// examples/reti/stakingPool.algo.ts:428
	// this.stakers.value[i] = cmpStaker
	frame_dig 1 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 2 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

	// examples/reti/stakingPool.algo.ts:433
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeRemoved>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 22 //  method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:434
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:435
	// methodArgs: [
	//             { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//             staker,
	//             0, // no algo removed
	//             amountRewardTokenRemoved,
	//             false, // staker isn't being removed.
	//           ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 0 // staker: address
	itxn_field ApplicationArgs
	bytec 9 // 0x0000000000000000
	itxn_field ApplicationArgs
	frame_dig 3 // amountRewardTokenRemoved: uint64
	itob
	itxn_field ApplicationArgs
	intc 0 // 0
	bytec 26 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:443
	// return;
	retsub

*if15_end:

*for_2_continue:
	// examples/reti/stakingPool.algo.ts:393
	// i += 1
	frame_dig 1 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // i: uint64
	b *for_2

*for_2_end:
	// account not found
	err
	retsub

// getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
*abi_route_getStakerInfo:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakerInfo must be a address
	assert

	// execute getStakerInfo(address)(address,uint64,uint64,uint64,uint64)
	callsub getStakerInfo
	concat
	log
	intc 1 // 1
	return

// getStakerInfo(staker: Address): StakedInfo
//
// Retrieves the staked information for a given staker.
//
// @param {Address} staker - The address of the staker.
// @returns {StakedInfo} - The staked information for the given staker.
// @throws {Error} - If the staker's account is not found.
getStakerInfo:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:458
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 0 // i: uint64

*for_3:
	// examples/reti/stakingPool.algo.ts:458
	// i < this.stakers.value.length
	frame_dig 0 // i: uint64
	intc 7 // 200
	<
	bz *for_3_end

	// *if18_condition
	// examples/reti/stakingPool.algo.ts:459
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if18_end

	// *if18_consequent
	// examples/reti/stakingPool.algo.ts:460
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if18_end:
	// *if19_condition
	// examples/reti/stakingPool.algo.ts:462
	// this.stakers.value[i].account === staker
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 0 // 0
	+
	intc 4 // 32
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_dig -1 // staker: Address
	==
	bz *if19_end

	// *if19_consequent
	// examples/reti/stakingPool.algo.ts:463
	// return this.stakers.value[i];
	frame_dig 0 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	b *getStakerInfo*return

*if19_end:

*for_3_continue:
	// examples/reti/stakingPool.algo.ts:458
	// i += 1
	frame_dig 0 // i: uint64
	intc 1 // 1
	+
	frame_bury 0 // i: uint64
	b *for_3

*for_3_end:
	// account not found
	err

*getStakerInfo*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// payTokenReward(address,uint64,uint64)void
*abi_route_payTokenReward:
	// amountToSend: uint64
	txna ApplicationArgs 3
	btoi

	// rewardToken: uint64
	txna ApplicationArgs 2
	btoi

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 2 (staker) for payTokenReward must be a address
	assert

	// execute payTokenReward(address,uint64,uint64)void
	callsub payTokenReward
	intc 1 // 1
	return

// payTokenReward(staker: Address, rewardToken: uint64, amountToSend: uint64): void
//
// [Internal protocol method] Remove a specified amount of 'community token' rewards for a staker.
// This can ONLY be called by our validator and only if we're pool 1 - with the token.
// Note: this can also be called by validator as part of OWNER wanting to send the reward tokens
// somewhere else (ie if they're sunsetting their validator and need the reward tokens back).
// It's up to the validator to ensure that the balance in rewardTokenHeldBack is honored.
// @param staker - the staker account to send rewards to
// @param rewardToken - id of reward token (to avoid re-entrancy in calling validator back to get id)
// @param amountToSend - amount to send the staker (there is significant trust here(!) - also why only validator can call us
payTokenReward:
	proto 3 0

	// examples/reti/stakingPool.algo.ts:481
	// assert(
	//       this.txn.sender === AppID.fromUint64(this.creatingValidatorContractAppId.value).address,
	//       'this can only be called via the validator contract'
	//     )
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	==

	// this can only be called via the validator contract
	assert

	// examples/reti/stakingPool.algo.ts:485
	// assert(this.poolId.value === 1, 'must be pool 1 in order to be called to pay out token rewards')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// must be pool 1 in order to be called to pay out token rewards
	assert

	// examples/reti/stakingPool.algo.ts:486
	// assert(rewardToken !== 0, 'can only claim token rewards from validator that has them')
	frame_dig -2 // rewardToken: uint64
	intc 0 // 0
	!=

	// can only claim token rewards from validator that has them
	assert

	// examples/reti/stakingPool.algo.ts:489
	// sendAssetTransfer({
	//       xferAsset: AssetID.fromUint64(rewardToken),
	//       assetReceiver: staker,
	//       assetAmount: amountToSend,
	//     })
	itxn_begin
	intc 11 //  axfer
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:490
	// xferAsset: AssetID.fromUint64(rewardToken)
	frame_dig -2 // rewardToken: uint64
	itxn_field XferAsset

	// examples/reti/stakingPool.algo.ts:491
	// assetReceiver: staker
	frame_dig -1 // staker: Address
	itxn_field AssetReceiver

	// examples/reti/stakingPool.algo.ts:492
	// assetAmount: amountToSend
	frame_dig -3 // amountToSend: uint64
	itxn_field AssetAmount

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// updateAlgodVer(string)void
*abi_route_updateAlgodVer:
	// algodVer: string
	txna ApplicationArgs 1
	extract 2 0

	// execute updateAlgodVer(string)void
	callsub updateAlgodVer
	intc 1 // 1
	return

// updateAlgodVer(algodVer: string): void
//
// Update the (honor system) algod version for the node associated to this pool.  The node management daemon
// should compare its current nodes version to the version stored in global state, updating when different.
// The reti node daemon composes its own version string using format:
// {major}.{minor}.{build} {branch} [{commit hash}],
// ie: 3.22.0 rel/stable [6b508975]
// [ ONLY OWNER OR MANAGER CAN CALL ]
// @param {string} algodVer - string representing the algorand node daemon version (reti node daemon composes its own meta version)
updateAlgodVer:
	proto 1 0

	// examples/reti/stakingPool.algo.ts:506
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:507
	// this.algodVer.value = algodVer
	pushbytes 0x616c676f64566572 // "algodVer"
	frame_dig -1 // algodVer: string
	app_global_put
	retsub

// epochBalanceUpdate()void
*abi_route_epochBalanceUpdate:
	// execute epochBalanceUpdate()void
	callsub epochBalanceUpdate
	intc 1 // 1
	return

// epochBalanceUpdate(): void
//
// Updates the balance of stakers in the pool based on the received 'rewards' (current balance vs known staked balance)
// stakers outstanding balance is adjusted based on their % of stake and time in the current epoch - so that balance
// compounds over time and staker can remove that amount at will.
// The validator is paid their percentage each epoch payout.
//
// Note: ANYONE can call this.
epochBalanceUpdate:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 36

	// examples/reti/stakingPool.algo.ts:520
	// validatorConfig = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorConfig>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 15 //  method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:521
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:522
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:529
	// epochRoundLength = validatorConfig.epochRoundLength as uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 169 4
	btoi
	frame_bury 1 // epochRoundLength: uint64

	// examples/reti/stakingPool.algo.ts:530
	// curRound = globals.round
	global Round
	frame_bury 2 // curRound: uint64

	// examples/reti/stakingPool.algo.ts:531
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 2 // curRound: uint64
	frame_dig 2 // curRound: uint64
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 3 // thisEpochBegin: uint64

	// *if20_condition
	// examples/reti/stakingPool.algo.ts:534
	// this.lastPayout.exists
	txna Applications 0
	bytec 14 //  "lastPayout"
	app_global_get_ex
	swap
	pop
	bz *if20_end

	// *if20_consequent
	// examples/reti/stakingPool.algo.ts:535
	// lastPayoutEpoch = this.lastPayout.value - (this.lastPayout.value % epochRoundLength)
	bytec 14 //  "lastPayout"
	app_global_get
	bytec 14 //  "lastPayout"
	app_global_get
	frame_dig 1 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // lastPayoutEpoch: uint64

	// examples/reti/stakingPool.algo.ts:539
	// assert(lastPayoutEpoch !== thisEpochBegin, "can't call epochBalanceUpdate in same epoch as prior call")
	frame_dig 4 // lastPayoutEpoch: uint64
	frame_dig 3 // thisEpochBegin: uint64
	!=

	// can't call epochBalanceUpdate in same epoch as prior call
	assert

*if20_end:
	// examples/reti/stakingPool.algo.ts:542
	// this.checkIfBinClosed()
	callsub checkIfBinClosed

	// examples/reti/stakingPool.algo.ts:545
	// this.lastPayout.value = curRound
	bytec 14 //  "lastPayout"
	frame_dig 2 // curRound: uint64
	app_global_put

	// examples/reti/stakingPool.algo.ts:546
	// this.epochNumber.value += 1
	bytec 19 //  "epochNumber"
	app_global_get
	intc 1 // 1
	+
	bytec 19 //  "epochNumber"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:551
	// isTokenEligible = validatorConfig.rewardTokenId !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	intc 0 // 0
	!=
	frame_bury 5 // isTokenEligible: bool

	// examples/reti/stakingPool.algo.ts:552
	// poolOneAppID = this.app.id
	txna Applications 0
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:553
	// poolOneAddress = this.app.address
	global CurrentApplicationAddress
	frame_bury 7 // poolOneAddress: address

	// *if21_condition
	// examples/reti/stakingPool.algo.ts:558
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if21_end

	// *if21_consequent
	// *if22_condition
	// examples/reti/stakingPool.algo.ts:559
	// this.poolId.value !== 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	!=
	bz *if22_end

	// *if22_consequent
	// examples/reti/stakingPool.algo.ts:561
	// poolOneAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value, 1],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:562
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:563
	// methodArgs: [this.validatorId.value, 1]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs
	pushbytes 0x0000000000000001
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 6 // poolOneAppID: uint64

	// examples/reti/stakingPool.algo.ts:565
	// poolOneAddress = AppID.fromUint64(poolOneAppID).address
	frame_dig 6 // poolOneAppID: uint64
	app_params_get AppAddress
	pop
	frame_bury 7 // poolOneAddress: address

*if22_end:
	// *if23_condition
	// examples/reti/stakingPool.algo.ts:570
	// this.poolId.value === 1
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==
	bz *if23_else

	// *if23_consequent
	// examples/reti/stakingPool.algo.ts:571
	// tokenPayoutRatio = sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//           methodArgs: [this.validatorId.value],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:572
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:573
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	b *if23_end

*if23_else:
	// examples/reti/stakingPool.algo.ts:577
	// tokenPayoutRatio = sendMethodCall<typeof StakingPool.prototype.proxiedSetTokenPayoutRatio>({
	//           applicationID: AppID.fromUint64(poolOneAppID),
	//           methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }],
	//         })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:578
	// applicationID: AppID.fromUint64(poolOneAppID)
	frame_dig 6 // poolOneAppID: uint64
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:579
	// methodArgs: [{ id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 8 // tokenPayoutRatio: PoolTokenPayoutRatio

*if23_end:

*if21_end:
	// examples/reti/stakingPool.algo.ts:586
	// validatorState = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorState>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:587
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:588
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 9 // validatorState: (uint16,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:590
	// rewardTokenHeldBack = validatorState.rewardTokenHeldBack
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 18 8
	btoi
	frame_bury 10 // rewardTokenHeldBack: uint64

	// examples/reti/stakingPool.algo.ts:596
	// algoRewardAvail = this.app.address.balance - this.totalAlgoStaked.value - this.app.address.minBalance
	global CurrentApplicationAddress
	acct_params_get AcctBalance
	pop
	bytec 6 //  "staked"
	app_global_get
	-
	global CurrentApplicationAddress
	acct_params_get AcctMinBalance
	pop
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:597
	// isPoolSaturated = false
	intc 0 // 0
	frame_bury 12 // isPoolSaturated: bool

	// examples/reti/stakingPool.algo.ts:598
	// algoSaturationAmt = this.algoSaturationLevel()
	callsub algoSaturationLevel
	frame_bury 13 // algoSaturationAmt: uint64

	// *if24_condition
	// examples/reti/stakingPool.algo.ts:606
	// validatorState.totalAlgoStaked > algoSaturationAmt
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	frame_dig 13 // algoSaturationAmt: uint64
	>
	bz *if24_end

	// *if24_consequent
	// examples/reti/stakingPool.algo.ts:607
	// isPoolSaturated = true
	intc 1 // 1
	frame_bury 12 // isPoolSaturated: bool

*if24_end:
	// examples/reti/stakingPool.algo.ts:613
	// tokenRewardAvail = 0
	intc 0 // 0
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:614
	// tokenRewardPaidOut = 0
	intc 0 // 0
	frame_bury 15 // tokenRewardPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:615
	// validatorCommissionPaidOut = 0
	intc 0 // 0
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:616
	// excessToFeeSink = 0
	intc 0 // 0
	frame_bury 17 // excessToFeeSink: uint64

	// *if25_condition
	// examples/reti/stakingPool.algo.ts:617
	// isTokenEligible
	frame_dig 5 // isTokenEligible: bool
	bz *if25_end

	// *if25_consequent
	// examples/reti/stakingPool.algo.ts:618
	// tokenRewardBal =
	//         poolOneAddress.assetBalance(AssetID.fromUint64(validatorConfig.rewardTokenId)) - rewardTokenHeldBack
	frame_dig 7 // poolOneAddress: address
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 153 8
	btoi
	asset_holding_get AssetBalance
	pop
	frame_dig 10 // rewardTokenHeldBack: uint64
	-
	frame_bury 18 // tokenRewardBal: uint64

	// *if26_condition
	// examples/reti/stakingPool.algo.ts:623
	// tokenRewardBal >= validatorConfig.rewardPerPayout
	frame_dig 18 // tokenRewardBal: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	>=
	bz *if26_end

	// *if26_consequent
	// examples/reti/stakingPool.algo.ts:629
	// ourPoolPctOfWhole = tokenPayoutRatio.poolPctOfWhole[this.poolId.value - 1]
	frame_dig 8 // tokenPayoutRatio: PoolTokenPayoutRatio
	intc 0 // 0
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	-
	intc 14 // 8
	* // acc * typeLength
	+
	intc 14 // 8
	extract3
	btoi
	frame_bury 19 // ourPoolPctOfWhole: uint64

	// examples/reti/stakingPool.algo.ts:632
	// tokenRewardAvail = wideRatio([validatorConfig.rewardPerPayout, ourPoolPctOfWhole], [1_000_000])
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 161 8
	btoi
	frame_dig 19 // ourPoolPctOfWhole: uint64
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 14 // tokenRewardAvail: uint64

*if26_end:

*if25_end:
	// *if27_condition
	// examples/reti/stakingPool.algo.ts:635
	// tokenRewardAvail === 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	==
	bz *if27_end

	// *if27_consequent
	// *if28_condition
	// examples/reti/stakingPool.algo.ts:640
	// algoRewardAvail < 1_000_000
	frame_dig 11 // algoRewardAvail: uint64
	intc 12 // 1_000_000
	<
	bz *if28_end

	// *if28_consequent
	// examples/reti/stakingPool.algo.ts:641
	// log('!token&&!noalgo to pay')
	pushbytes 0x21746f6b656e2626216e6f616c676f20746f20706179 // "!token&&!noalgo to pay"
	log

	// examples/reti/stakingPool.algo.ts:642
	// return;
	retsub

*if28_end:

*if27_end:
	// *if29_condition
	// examples/reti/stakingPool.algo.ts:646
	// isPoolSaturated
	frame_dig 12 // isPoolSaturated: bool
	bz *if29_elseif1_condition

	// *if29_consequent
	// examples/reti/stakingPool.algo.ts:649
	// diminishedReward = wideRatio([algoRewardAvail, algoSaturationAmt], [validatorState.totalAlgoStaked])
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 13 // algoSaturationAmt: uint64
	mulw
	intc 0 // 0
	frame_dig 9 // validatorState: (uint16,uint64,uint64,uint64)
	extract 10 8
	btoi
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 20 // diminishedReward: uint64

	// examples/reti/stakingPool.algo.ts:651
	// excessToFeeSink = algoRewardAvail - diminishedReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 20 // diminishedReward: uint64
	-
	frame_bury 17 // excessToFeeSink: uint64

	// examples/reti/stakingPool.algo.ts:652
	// sendPayment({
	//         amount: excessToFeeSink,
	//         receiver: this.getFeeSink(),
	//         note: 'pool saturated, excess to fee sink',
	//       })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:653
	// amount: excessToFeeSink
	frame_dig 17 // excessToFeeSink: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:654
	// receiver: this.getFeeSink()
	callsub getFeeSink
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:655
	// note: 'pool saturated, excess to fee sink'
	pushbytes 0x706f6f6c207361747572617465642c2065786365737320746f206665652073696e6b // "pool saturated, excess to fee sink"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/stakingPool.algo.ts:658
	// algoRewardAvail = diminishedReward
	frame_dig 20 // diminishedReward: uint64
	frame_bury 11 // algoRewardAvail: uint64
	b *if29_end

*if29_elseif1_condition:
	// examples/reti/stakingPool.algo.ts:659
	// validatorConfig.percentToValidator !== 0
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if29_end

	// *if29_elseif1_consequent
	// examples/reti/stakingPool.algo.ts:662
	// validatorCommissionPaidOut = wideRatio(
	//         [algoRewardAvail, validatorConfig.percentToValidator as uint64],
	//         [1_000_000]
	//       )
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 173 4
	btoi
	mulw
	intc 0 // 0
	intc 12 // 1_000_000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 16 // validatorCommissionPaidOut: uint64

	// examples/reti/stakingPool.algo.ts:668
	// algoRewardAvail -= validatorCommissionPaidOut
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 16 // validatorCommissionPaidOut: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// *if30_condition
	// examples/reti/stakingPool.algo.ts:675
	// validatorCommissionPaidOut > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 0 // 0
	>
	bz *if30_end

	// *if30_consequent
	// examples/reti/stakingPool.algo.ts:678
	// managerTopOff = 0
	intc 0 // 0
	frame_bury 21 // managerTopOff: uint64

	// *if31_condition
	// examples/reti/stakingPool.algo.ts:680
	// validatorConfig.manager !== validatorConfig.validatorCommissionAddress &&
	//           validatorConfig.manager.balance - validatorConfig.manager.minBalance < 2_100_000
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	!=
	dup
	bz *skip_and3
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctBalance
	pop
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	acct_params_get AcctMinBalance
	pop
	-
	intc 13 // 2_100_000
	<
	&&

*skip_and3:
	bz *if31_end

	// *if31_consequent
	// examples/reti/stakingPool.algo.ts:683
	// managerTopOff = validatorCommissionPaidOut < 2_100_000 ? validatorCommissionPaidOut : 2_100_000
	frame_dig 16 // validatorCommissionPaidOut: uint64
	intc 13 // 2_100_000
	<
	bz *ternary1_false
	frame_dig 16 // validatorCommissionPaidOut: uint64
	b *ternary1_end

*ternary1_false:
	intc 13 // 2_100_000

*ternary1_end:
	frame_bury 21 // managerTopOff: uint64

	// examples/reti/stakingPool.algo.ts:684
	// sendPayment({
	//             amount: managerTopOff,
	//             receiver: validatorConfig.manager,
	//             note: 'validator reward to manager for funding epoch updates',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:685
	// amount: managerTopOff
	frame_dig 21 // managerTopOff: uint64
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:686
	// receiver: validatorConfig.manager
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 40 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:687
	// note: 'validator reward to manager for funding epoch updates'
	pushbytes 0x76616c696461746f722072657761726420746f206d616e6167657220666f722066756e64696e672065706f63682075706461746573 // "validator reward to manager for funding epoch updates"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if31_end:
	// *if32_condition
	// examples/reti/stakingPool.algo.ts:690
	// validatorCommissionPaidOut - managerTopOff > 0
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	intc 0 // 0
	>
	bz *if32_end

	// *if32_consequent
	// examples/reti/stakingPool.algo.ts:691
	// sendPayment({
	//             amount: validatorCommissionPaidOut - managerTopOff,
	//             receiver: validatorConfig.validatorCommissionAddress,
	//             note: 'validator reward',
	//           })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:692
	// amount: validatorCommissionPaidOut - managerTopOff
	frame_dig 16 // validatorCommissionPaidOut: uint64
	frame_dig 21 // managerTopOff: uint64
	-
	itxn_field Amount

	// examples/reti/stakingPool.algo.ts:693
	// receiver: validatorConfig.validatorCommissionAddress
	frame_dig 0 // validatorConfig: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 177 32
	itxn_field Receiver

	// examples/reti/stakingPool.algo.ts:694
	// note: 'validator reward'
	pushbytes 0x76616c696461746f7220726577617264 // "validator reward"
	itxn_field Note

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if32_end:

*if30_end:

*if29_end:
	// examples/reti/stakingPool.algo.ts:706
	// increasedStake = 0
	intc 0 // 0
	frame_bury 22 // increasedStake: uint64

	// *if33_condition
	// examples/reti/stakingPool.algo.ts:730
	// algoRewardAvail !== 0 || tokenRewardAvail !== 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	!=
	dup
	bnz *skip_or1
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	!=
	||

*skip_or1:
	bz *if33_end

	// *if33_consequent
	// examples/reti/stakingPool.algo.ts:731
	// partialStakersTotalStake: uint64 = 0
	intc 0 // 0
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:732
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 24 // i: uint64

*for_4:
	// examples/reti/stakingPool.algo.ts:732
	// i < this.stakers.value.length
	frame_dig 24 // i: uint64
	intc 7 // 200
	<
	bz *for_4_end

	// *if34_condition
	// examples/reti/stakingPool.algo.ts:733
	// globals.opcodeBudget < 400
	global OpcodeBudget
	intc 16 // 400
	<
	bz *if34_end

	// *if34_consequent
	// examples/reti/stakingPool.algo.ts:734
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if34_end:
	// examples/reti/stakingPool.algo.ts:736
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if35_condition
	// examples/reti/stakingPool.algo.ts:737
	// cmpStaker.account !== globals.zeroAddress
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	bz *if35_end

	// *if35_consequent
	// *if36_condition
	// examples/reti/stakingPool.algo.ts:738
	// cmpStaker.entryRound >= thisEpochBegin
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	>=
	bz *if36_else

	// *if36_consequent
	// examples/reti/stakingPool.algo.ts:741
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64
	b *if36_end

*if36_else:
	// examples/reti/stakingPool.algo.ts:745
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 26 // timeInPool: uint64

	// *if37_condition
	// examples/reti/stakingPool.algo.ts:749
	// timeInPool < epochRoundLength
	frame_dig 26 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	<
	bz *if37_end

	// *if37_consequent
	// examples/reti/stakingPool.algo.ts:750
	// partialStakersTotalStake += cmpStaker.balance
	frame_dig 23 // partialStakersTotalStake: uint64
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	+
	frame_bury 23 // partialStakersTotalStake: uint64

	// examples/reti/stakingPool.algo.ts:751
	// timePercentage = (timeInPool * 1000) / epochRoundLength
	frame_dig 26 // timeInPool: uint64
	intc 10 // 1000
	*
	frame_dig 1 // epochRoundLength: uint64
	/
	frame_bury 27 // timePercentage: uint64

	// *if38_condition
	// examples/reti/stakingPool.algo.ts:753
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if38_end

	// *if38_consequent
	// examples/reti/stakingPool.algo.ts:755
	// stakerTokenReward = wideRatio(
	//                   [cmpStaker.balance, tokenRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 28 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:762
	// tokenRewardAvail -= stakerTokenReward
	frame_dig 14 // tokenRewardAvail: uint64
	frame_dig 28 // stakerTokenReward: uint64
	-
	frame_bury 14 // tokenRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:763
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 28 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:764
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 28 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if38_end:
	// *if39_condition
	// examples/reti/stakingPool.algo.ts:766
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if39_end

	// *if39_consequent
	// examples/reti/stakingPool.algo.ts:768
	// stakerReward = wideRatio(
	//                   [cmpStaker.balance, algoRewardAvail, timePercentage],
	//                   [this.totalAlgoStaked.value, 1000]
	//                 )
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	frame_dig 27 // timePercentage: uint64
	uncover 2
	dig 1
	*
	cover 2
	mulw
	cover 2
	+
	swap
	bytec 6 //  "staked"
	app_global_get
	intc 10 // 1000
	mulw
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 29 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:775
	// algoRewardAvail -= stakerReward
	frame_dig 11 // algoRewardAvail: uint64
	frame_dig 29 // stakerReward: uint64
	-
	frame_bury 11 // algoRewardAvail: uint64

	// examples/reti/stakingPool.algo.ts:778
	// cmpStaker.balance += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:779
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 29 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:780
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 29 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if39_end:
	// examples/reti/stakingPool.algo.ts:783
	// this.stakers.value[i] = cmpStaker
	frame_dig 24 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 25 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if37_end:

*if36_end:

*if35_end:

*for_4_continue:
	// examples/reti/stakingPool.algo.ts:732
	// i += 1
	frame_dig 24 // i: uint64
	intc 1 // 1
	+
	frame_bury 24 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/stakingPool.algo.ts:791
	// newPoolTotalStake = this.totalAlgoStaked.value - partialStakersTotalStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 23 // partialStakersTotalStake: uint64
	-
	frame_bury 30 // newPoolTotalStake: uint64

	// *if40_condition
	// examples/reti/stakingPool.algo.ts:795
	// newPoolTotalStake > 0
	frame_dig 30 // newPoolTotalStake: uint64
	intc 0 // 0
	>
	bz *if40_end

	// *if40_consequent
	// examples/reti/stakingPool.algo.ts:797
	// for (let i = 0; i < this.stakers.value.length; i += 1)
	intc 0 // 0
	frame_bury 31 // i: uint64

*for_5:
	// examples/reti/stakingPool.algo.ts:797
	// i < this.stakers.value.length
	frame_dig 31 // i: uint64
	intc 7 // 200
	<
	bz *for_5_end

	// *if41_condition
	// examples/reti/stakingPool.algo.ts:798
	// globals.opcodeBudget < 200
	global OpcodeBudget
	intc 7 // 200
	<
	bz *if41_end

	// *if41_consequent
	// examples/reti/stakingPool.algo.ts:799
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if41_end:
	// examples/reti/stakingPool.algo.ts:801
	// cmpStaker = clone(this.stakers.value[i])
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	intc 3 // 64
	bytec 2 //  "stakers"
	cover 2
	box_extract
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// *if42_condition
	// examples/reti/stakingPool.algo.ts:802
	// cmpStaker.account !== globals.zeroAddress && cmpStaker.entryRound < thisEpochBegin
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 0 32
	global ZeroAddress
	!=
	dup
	bz *skip_and4
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	frame_dig 3 // thisEpochBegin: uint64
	<
	&&

*skip_and4:
	bz *if42_end

	// *if42_consequent
	// examples/reti/stakingPool.algo.ts:803
	// timeInPool = thisEpochBegin - cmpStaker.entryRound
	frame_dig 3 // thisEpochBegin: uint64
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 56 8
	btoi
	-
	frame_bury 33 // timeInPool: uint64

	// *if43_condition
	// examples/reti/stakingPool.algo.ts:805
	// timeInPool >= epochRoundLength
	frame_dig 33 // timeInPool: uint64
	frame_dig 1 // epochRoundLength: uint64
	>=
	bz *if43_end

	// *if43_consequent
	// *if44_condition
	// examples/reti/stakingPool.algo.ts:810
	// tokenRewardAvail > 0
	frame_dig 14 // tokenRewardAvail: uint64
	intc 0 // 0
	>
	bz *if44_end

	// *if44_consequent
	// examples/reti/stakingPool.algo.ts:811
	// stakerTokenReward = wideRatio([cmpStaker.balance, tokenRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 14 // tokenRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 34 // stakerTokenReward: uint64

	// examples/reti/stakingPool.algo.ts:814
	// cmpStaker.rewardTokenBalance += stakerTokenReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 19 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 48 8
	btoi
	frame_dig 34 // stakerTokenReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:815
	// tokenRewardPaidOut += stakerTokenReward
	frame_dig 15 // tokenRewardPaidOut: uint64
	frame_dig 34 // stakerTokenReward: uint64
	+
	frame_bury 15 // tokenRewardPaidOut: uint64

*if44_end:
	// *if45_condition
	// examples/reti/stakingPool.algo.ts:817
	// algoRewardAvail > 0
	frame_dig 11 // algoRewardAvail: uint64
	intc 0 // 0
	>
	bz *if45_end

	// *if45_consequent
	// examples/reti/stakingPool.algo.ts:818
	// stakerReward = wideRatio([cmpStaker.balance, algoRewardAvail], [newPoolTotalStake])
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 11 // algoRewardAvail: uint64
	mulw
	intc 0 // 0
	frame_dig 30 // newPoolTotalStake: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 35 // stakerReward: uint64

	// examples/reti/stakingPool.algo.ts:821
	// cmpStaker.balance += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 4 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 32 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:822
	// cmpStaker.totalRewarded += stakerReward
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	intc 18 //  headOffset
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	extract 40 8
	btoi
	frame_dig 35 // stakerReward: uint64
	+
	itob
	replace3
	frame_bury 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)

	// examples/reti/stakingPool.algo.ts:823
	// increasedStake += stakerReward
	frame_dig 22 // increasedStake: uint64
	frame_dig 35 // stakerReward: uint64
	+
	frame_bury 22 // increasedStake: uint64

*if45_end:
	// examples/reti/stakingPool.algo.ts:827
	// this.stakers.value[i] = cmpStaker
	frame_dig 31 // i: uint64
	intc 3 // 64
	* // acc * typeLength
	frame_dig 32 // cmpStaker: (address,uint64,uint64,uint64,uint64)
	bytec 2 //  "stakers"
	cover 2
	box_replace

*if43_end:

*if42_end:

*for_5_continue:
	// examples/reti/stakingPool.algo.ts:797
	// i += 1
	frame_dig 31 // i: uint64
	intc 1 // 1
	+
	frame_bury 31 // i: uint64
	b *for_5

*for_5_end:

*if40_end:

*if33_end:
	// examples/reti/stakingPool.algo.ts:837
	// roundsLeftInBin = this.binRoundStart.value + this.roundsPerDay.value - globals.round
	bytec 11 //  "binRoundStart"
	app_global_get
	bytec 10 //  "roundsPerDay"
	app_global_get
	+
	global Round
	-
	frame_bury 36 // roundsLeftInBin: uint64

	// examples/reti/stakingPool.algo.ts:838
	// this.totalAlgoStaked.value += increasedStake
	bytec 6 //  "staked"
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	bytec 6 //  "staked"
	swap
	app_global_put

	// examples/reti/stakingPool.algo.ts:839
	// this.stakeAccumulator.value =
	//       this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128)
	bytec 7 //  "stakeAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	itob
	frame_dig 36 // roundsLeftInBin: uint64
	itob
	b*
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value + (increasedStake as uint128) * (roundsLeftInBin as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:841
	// this.rewardAccumulator.value = this.rewardAccumulator.value + increasedStake
	bytec 12 //  "rewardAccumulator"
	dup
	app_global_get
	frame_dig 22 // increasedStake: uint64
	+
	app_global_put

	// examples/reti/stakingPool.algo.ts:847
	// sendMethodCall<typeof ValidatorRegistry.prototype.stakeUpdatedViaRewards>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:848
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:849
	// methodArgs: [
	//         { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id },
	//         increasedStake,
	//         tokenRewardPaidOut,
	//         validatorCommissionPaidOut,
	//         excessToFeeSink,
	//       ]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	bytec 4 //  "poolId"
	app_global_get
	itob
	concat
	txna Applications 0
	itob
	concat
	itxn_field ApplicationArgs
	frame_dig 22 // increasedStake: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 15 // tokenRewardPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 16 // validatorCommissionPaidOut: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 17 // excessToFeeSink: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
*abi_route_goOnline:
	// voteKeyDilution: uint64
	txna ApplicationArgs 6
	btoi

	// voteLast: uint64
	txna ApplicationArgs 5
	btoi

	// voteFirst: uint64
	txna ApplicationArgs 4
	btoi

	// stateProofPK: byte[]
	txna ApplicationArgs 3
	extract 2 0

	// selectionPK: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// votePK: byte[]
	txna ApplicationArgs 1
	extract 2 0

	// feePayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 6 (feePayment) for goOnline must be a pay transaction
	assert

	// execute goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void
	callsub goOnline
	intc 1 // 1
	return

// goOnline(feePayment: PayTxn, votePK: bytes, selectionPK: bytes, stateProofPK: bytes, voteFirst: uint64, voteLast: uint64, voteKeyDilution: uint64): void
//
// Registers a staking pool key online against a participation key.
// [ ONLY OWNER OR MANAGER CAN CALL ]
//
// @param {PayTxn} feePayment - payment to cover extra fee of going online if offline - or 0 if not renewal
// @param {bytes} votePK - The vote public key.
// @param {bytes} selectionPK - The selection public key.
// @param {bytes} stateProofPK - The state proof public key.
// @param {uint64} voteFirst - The first vote index.
// @param {uint64} voteLast - The last vote index.
// @param {uint64} voteKeyDilution - The vote key dilution value.
// @throws {Error} Will throw an error if the caller is not the owner or a manager.
goOnline:
	proto 7 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:881
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:882
	// extraFee = this.getGoOnlineFee()
	callsub getGoOnlineFee
	frame_bury 0 // extraFee: uint64

	// examples/reti/stakingPool.algo.ts:883
	// verifyPayTxn(feePayment, { receiver: this.app.address, amount: extraFee })
	// verify receiver
	frame_dig -1 // feePayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"feePayment","field":"receiver","expected":"this.app.address"}
	assert

	// verify amount
	frame_dig -1 // feePayment: PayTxn
	gtxns Amount
	frame_dig 0 // extraFee: uint64
	==

	// transaction verification failed: {"txn":"feePayment","field":"amount","expected":"extraFee"}
	assert

	// examples/reti/stakingPool.algo.ts:884
	// sendOnlineKeyRegistration({
	//       votePK: votePK,
	//       selectionPK: selectionPK,
	//       stateProofPK: stateProofPK,
	//       voteFirst: voteFirst,
	//       voteLast: voteLast,
	//       voteKeyDilution: voteKeyDilution,
	//       fee: this.getGoOnlineFee(),
	//     })
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:885
	// votePK: votePK
	frame_dig -2 // votePK: bytes
	itxn_field VotePK

	// examples/reti/stakingPool.algo.ts:886
	// selectionPK: selectionPK
	frame_dig -3 // selectionPK: bytes
	itxn_field SelectionPK

	// examples/reti/stakingPool.algo.ts:887
	// stateProofPK: stateProofPK
	frame_dig -4 // stateProofPK: bytes
	itxn_field StateProofPK

	// examples/reti/stakingPool.algo.ts:888
	// voteFirst: voteFirst
	frame_dig -5 // voteFirst: uint64
	itxn_field VoteFirst

	// examples/reti/stakingPool.algo.ts:889
	// voteLast: voteLast
	frame_dig -6 // voteLast: uint64
	itxn_field VoteLast

	// examples/reti/stakingPool.algo.ts:890
	// voteKeyDilution: voteKeyDilution
	frame_dig -7 // voteKeyDilution: uint64
	itxn_field VoteKeyDilution

	// examples/reti/stakingPool.algo.ts:891
	// fee: this.getGoOnlineFee()
	callsub getGoOnlineFee
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// goOffline()void
*abi_route_goOffline:
	// execute goOffline()void
	callsub goOffline
	intc 1 // 1
	return

// goOffline(): void
//
// Marks a staking pool key OFFLINE.
// [ ONLY OWNER OR MANAGER CAN CALL ]
goOffline:
	proto 0 0

	// *if46_condition
	// examples/reti/stakingPool.algo.ts:903
	// this.txn.sender !== AppID.fromUint64(this.creatingValidatorContractAppId.value).address
	txn Sender
	bytec 1 //  "creatorApp"
	app_global_get
	app_params_get AppAddress
	pop
	!=
	bz *if46_end

	// *if46_consequent
	// examples/reti/stakingPool.algo.ts:904
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

*if46_end:
	// examples/reti/stakingPool.algo.ts:907
	// sendOfflineKeyRegistration({})
	itxn_begin
	intc 17 //  keyreg
	itxn_field TypeEnum

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// linkToNFD(uint64,string)void
*abi_route_linkToNFD:
	// nfdName: string
	txna ApplicationArgs 2
	extract 2 0

	// nfdAppId: uint64
	txna ApplicationArgs 1
	btoi

	// execute linkToNFD(uint64,string)void
	callsub linkToNFD
	intc 1 // 1
	return

// linkToNFD(nfdAppId: uint64, nfdName: string): void
linkToNFD:
	proto 2 0

	// examples/reti/stakingPool.algo.ts:914
	// assert(this.isOwnerOrManagerCaller(), 'can only be called by owner or manager of validator')
	callsub isOwnerOrManagerCaller

	// can only be called by owner or manager of validator
	assert

	// examples/reti/stakingPool.algo.ts:916
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)],
	//       applications: [AppID.fromUint64(nfdAppId)],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum

	// examples/reti/stakingPool.algo.ts:917
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 20 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:918
	// applicationArgs: ['verify_nfd_addr', nfdName, itob(nfdAppId), rawBytes(this.app.address)]
	pushbytes 0x7665726966795f6e66645f61646472 // "verify_nfd_addr"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppId: uint64
	itob
	itxn_field ApplicationArgs
	global CurrentApplicationAddress
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:919
	// applications: [AppID.fromUint64(nfdAppId)]
	frame_dig -1 // nfdAppId: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	retsub

// proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
*abi_route_proxiedSetTokenPayoutRatio:
	// The ABI return prefix
	bytec 21 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	pushint 24
	==

	// argument 0 (poolKey) for proxiedSetTokenPayoutRatio must be a (uint64,uint64,uint64)
	assert

	// execute proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)
	callsub proxiedSetTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// proxiedSetTokenPayoutRatio(poolKey: ValidatorPoolKey): PoolTokenPayoutRatio
//
// proxiedSetTokenPayoutRatio is meant to be called by pools != 1 - calling US, pool #1
// We need to verify that we are in fact being called by another of OUR pools (not us)
// and then we'll call the validator on their behalf to update the token payouts
// @param poolKey - ValidatorPoolKey tuple
proxiedSetTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:930
	// assert(this.validatorId.value === poolKey.id, 'caller must be part of same validator set!')
	bytec 3 //  "validatorId"
	app_global_get
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==

	// caller must be part of same validator set!
	assert

	// examples/reti/stakingPool.algo.ts:931
	// assert(this.poolId.value === 1, 'callee must be pool 1')
	bytec 4 //  "poolId"
	app_global_get
	intc 1 // 1
	==

	// callee must be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:932
	// assert(poolKey.poolId !== 1, 'caller must NOT be pool 1')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=

	// caller must NOT be pool 1
	assert

	// examples/reti/stakingPool.algo.ts:934
	// callerPoolAppID = sendMethodCall<typeof ValidatorRegistry.prototype.getPoolAppId>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [poolKey.id, poolKey.poolId],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 23 //  method "getPoolAppId(uint64,uint64)uint64"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:935
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:936
	// methodArgs: [poolKey.id, poolKey.poolId]
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	itxn_field ApplicationArgs
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi
	frame_bury 0 // callerPoolAppID: uint64

	// examples/reti/stakingPool.algo.ts:938
	// assert(callerPoolAppID === poolKey.poolAppId)
	frame_dig 0 // callerPoolAppID: uint64
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	==
	assert

	// examples/reti/stakingPool.algo.ts:939
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/stakingPool.algo.ts:941
	// return sendMethodCall<typeof ValidatorRegistry.prototype.setTokenPayoutRatio>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     });
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	bytec 24 //  method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:942
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:943
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0

	// set the subroutine return value
	frame_bury 0
	retsub

// isOwnerOrManagerCaller(): boolean
isOwnerOrManagerCaller:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:948
	// OwnerAndManager = sendMethodCall<typeof ValidatorRegistry.prototype.getValidatorOwnerAndManager>({
	//       applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value),
	//       methodArgs: [this.validatorId.value],
	//     })
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	itxn_field ApplicationArgs

	// examples/reti/stakingPool.algo.ts:949
	// applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value)
	bytec 1 //  "creatorApp"
	app_global_get
	itxn_field ApplicationID

	// examples/reti/stakingPool.algo.ts:950
	// methodArgs: [this.validatorId.value]
	bytec 3 //  "validatorId"
	app_global_get
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	frame_bury 0 // OwnerAndManager: (address,address)

	// examples/reti/stakingPool.algo.ts:952
	// return this.txn.sender === OwnerAndManager[0] || this.txn.sender === OwnerAndManager[1];
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 0 32
	==
	dup
	bnz *skip_or2
	txn Sender
	frame_dig 0 // OwnerAndManager: (address,address)
	extract 32 32
	==
	||

*skip_or2:
	// set the subroutine return value
	frame_bury 0
	retsub

// getFeeSink(): Address
getFeeSink:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:956
	// return this.feeSinkAddr;
	bytec 27 // TMPL_feeSinkAddr
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:966
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/stakingPool.algo.ts:968
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 10 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// getGoOnlineFee(): uint64
getGoOnlineFee:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x

	// examples/reti/stakingPool.algo.ts:975
	// isOnline = false
	intc 0 // 0
	frame_bury 0 // isOnline: bool

	// *if47_condition
	// examples/reti/stakingPool.algo.ts:976
	// !isOnline
	frame_dig 0 // isOnline: bool
	!
	bz *if47_end

	// *if47_consequent
	// examples/reti/stakingPool.algo.ts:978
	// return 2_000_000;
	pushint 2_000_000
	b *getGoOnlineFee*return

*if47_end:
	// examples/reti/stakingPool.algo.ts:980
	// return 0;
	intc 0 // 0

*getGoOnlineFee*return:
	// set the subroutine return value
	frame_bury 0
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/stakingPool.algo.ts:985
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// checkIfBinClosed(): void
//
// Checks if the current round is in a 'new calculation bin' (approximately daily)
checkIfBinClosed:
	proto 0 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 0 // 0x
	dupn 4

	// examples/reti/stakingPool.algo.ts:992
	// currentBinSize = this.roundsPerDay.value as uint128
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	frame_bury 0 // currentBinSize: unsafe uint128

	// *if48_condition
	// examples/reti/stakingPool.algo.ts:993
	// globals.round >= this.binRoundStart.value + (currentBinSize as uint64)
	global Round
	bytec 11 //  "binRoundStart"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	dup
	bitlen
	intc 3 // 64
	<=

	// currentBinSize as uint64 overflowed 64 bits
	assert
	pushbytes 0xFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 14 // 8
	-
	swap
	substring3
	btoi
	+
	>=
	bz *if48_end

	// *if48_consequent
	// *if49_condition
	// examples/reti/stakingPool.algo.ts:994
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 9 // 300
	<
	bz *if49_end

	// *if49_consequent
	// examples/reti/stakingPool.algo.ts:995
	// increaseOpcodeBudget()
	itxn_begin
	intc 2 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 5 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 8 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if49_end:
	// examples/reti/stakingPool.algo.ts:997
	// approxRoundsPerYear: uint128 = currentBinSize * (365 as uint128)
	frame_dig 0 // currentBinSize: unsafe uint128
	pushbytes 0x0000000000000000000000000000016d
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// currentBinSize * (365 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 1 // approxRoundsPerYear: uint128

	// examples/reti/stakingPool.algo.ts:998
	// avgStake: uint128 = this.stakeAccumulator.value / currentBinSize
	bytec 7 //  "stakeAccumulator"
	app_global_get
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	dup
	bitlen
	intc 6 // 128
	<=

	// this.stakeAccumulator.value / currentBinSize overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 2 // avgStake: uint128

	// *if50_condition
	// examples/reti/stakingPool.algo.ts:999
	// avgStake !== 0
	frame_dig 2 // avgStake: uint128
	bytec 16 // 0x00000000000000000000000000000000
	b!=
	bz *if50_end

	// *if50_consequent
	// examples/reti/stakingPool.algo.ts:1003
	// apr: uint128 =
	//           (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *
	//           (approxRoundsPerYear / currentBinSize)
	bytec 12 //  "rewardAccumulator"
	app_global_get
	itob
	pushbytes 0x00000000000000000000000000002710
	b*
	frame_dig 2 // avgStake: uint128
	b/
	frame_dig 1 // approxRoundsPerYear: uint128
	frame_dig 0 // currentBinSize: unsafe uint128
	b/
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (((this.rewardAccumulator.value as uint128) * (10000 as uint128)) / avgStake) *\n          (approxRoundsPerYear / currentBinSize) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	frame_bury 3 // apr: uint128

	// examples/reti/stakingPool.algo.ts:1007
	// alpha: uint128 = 10 as uint128
	pushbytes 0x0000000000000000000000000000000a
	frame_bury 4 // alpha: unsafe uint128

	// *if51_condition
	// examples/reti/stakingPool.algo.ts:1009
	// avgStake > 300000000000
	frame_dig 2 // avgStake: uint128
	pushbytes 0x000000000000000000000045d964b800
	b>
	bz *if51_end

	// *if51_consequent
	// examples/reti/stakingPool.algo.ts:1010
	// alpha = 90 as uint128
	pushbytes 0x0000000000000000000000000000005a
	frame_bury 4 // alpha: unsafe uint128

*if51_end:
	// examples/reti/stakingPool.algo.ts:1012
	// this.weightedMovingAverage.value =
	//           (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +
	//           (apr * alpha) / (100 as uint128)
	bytec 20 //  "ewma"
	dup
	app_global_get
	bytec 17 // 0x00000000000000000000000000000064
	frame_dig 4 // alpha: unsafe uint128
	b-
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	frame_dig 3 // apr: uint128
	frame_dig 4 // alpha: unsafe uint128
	b*
	bytec 17 // 0x00000000000000000000000000000064
	b/
	b+
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.weightedMovingAverage.value * ((100 as uint128) - alpha)) / (100 as uint128) +\n          (apr * alpha) / (100 as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

*if50_end:
	// examples/reti/stakingPool.algo.ts:1018
	// this.setRoundsPerDay()
	callsub setRoundsPerDay

	// examples/reti/stakingPool.algo.ts:1019
	// this.stakeAccumulator.value = (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128)
	bytec 7 //  "stakeAccumulator"
	bytec 6 //  "staked"
	app_global_get
	itob
	bytec 10 //  "roundsPerDay"
	app_global_get
	itob
	b*
	dup
	bitlen
	intc 6 // 128
	<=

	// (this.totalAlgoStaked.value as uint128) * (this.roundsPerDay.value as uint128) overflowed 128 bits
	assert
	bytec 8 // 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
	b&
	dup
	len
	dup
	intc 5 // 16
	-
	swap
	substring3
	app_global_put

	// examples/reti/stakingPool.algo.ts:1020
	// this.rewardAccumulator.value = 0
	bytec 12 //  "rewardAccumulator"
	intc 0 // 0
	app_global_put

	// examples/reti/stakingPool.algo.ts:1021
	// this.binRoundStart.value = globals.round - (globals.round % this.roundsPerDay.value)
	bytec 11 //  "binRoundStart"
	global Round
	global Round
	bytec 10 //  "roundsPerDay"
	app_global_get
	%
	-
	app_global_put

*if48_end:
	retsub

// setRoundsPerDay(): void
setRoundsPerDay:
	proto 0 0

	// examples/reti/stakingPool.algo.ts:1026
	// this.roundsPerDay.value = AVG_ROUNDS_PER_DAY
	bytec 10 //  "roundsPerDay"
	pushint 30857
	app_global_put
	retsub

*create_NoOp:
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x47cfcc04 // method "initStorage(pay)void"
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	pushbytes 0x421b5abe // method "removeStake(address,uint64)void"
	pushbytes 0xf5892d56 // method "claimTokens()void"
	pushbytes 0x5cfbb057 // method "getStakerInfo(address)(address,uint64,uint64,uint64,uint64)"
	pushbytes 0x63f3f28b // method "payTokenReward(address,uint64,uint64)void"
	pushbytes 0x86a3725c // method "updateAlgodVer(string)void"
	pushbytes 0xefc2608d // method "epochBalanceUpdate()void"
	pushbytes 0x400e14fb // method "goOnline(pay,byte[],byte[],byte[],uint64,uint64,uint64)void"
	pushbytes 0x51ef3b21 // method "goOffline()void"
	pushbytes 0xa24e2717 // method "linkToNFD(uint64,string)void"
	bytec 25 //  method "proxiedSetTokenPayoutRatio((uint64,uint64,uint64))(uint64[24],uint64)"
	txna ApplicationArgs 0
	match *abi_route_gas *abi_route_initStorage *abi_route_addStake *abi_route_removeStake *abi_route_claimTokens *abi_route_getStakerInfo *abi_route_payTokenReward *abi_route_updateAlgodVer *abi_route_epochBalanceUpdate *abi_route_goOnline *abi_route_goOffline *abi_route_linkToNFD *abi_route_proxiedSetTokenPayoutRatio

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "templateVariables": { diff --git a/examples/reti/stakingPool.algo.ts b/examples/reti/stakingPool.algo.ts index c3d1ea739..948a9df34 100644 --- a/examples/reti/stakingPool.algo.ts +++ b/examples/reti/stakingPool.algo.ts @@ -434,7 +434,7 @@ export class StakingPool extends Contract { applicationID: AppID.fromUint64(this.creatingValidatorContractAppId.value), methodArgs: [ { id: this.validatorId.value, poolId: this.poolId.value, poolAppId: this.app.id }, - clone(staker), + staker, 0, // no algo removed amountRewardTokenRemoved, false, // staker isn't being removed. From 78ca0c09f2a84708cbe9e966f9468ec11cb4a1c8 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Fri, 11 Apr 2025 16:22:55 -0400 Subject: [PATCH 06/29] wip: fix assignment check, function check, and tests --- src/lib/ref_checker.ts | 59 ++++++++++------ .../reference_compile_errors.algo.ts | 68 ------------------- .../MutableRefInArrayAssignment.algo.ts | 12 ++++ .../MutableRefInArrayLiteral.algo.ts | 13 ++++ .../MutableRefInObjAssignment.algo.ts | 20 ++++++ .../MutableRefInObjLiteral.algo.ts | 18 +++++ .../reference_errors/MutableRefInPush.algo.ts | 13 ++++ tests/references.test.ts | 40 ++++++++--- 8 files changed, 148 insertions(+), 95 deletions(-) delete mode 100644 tests/contracts/reference_compile_errors.algo.ts create mode 100644 tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts create mode 100644 tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts create mode 100644 tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts create mode 100644 tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts create mode 100644 tests/contracts/reference_errors/MutableRefInPush.algo.ts diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 2c9f9afa5..7277ca503 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -75,16 +75,50 @@ function referencesInVariableDeclaration(node: ts.Node, methodBody: ts.Node) { return nodes; } +/** References to the node in value assignment */ +function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression).forEach((n) => { + if (n.getOperatorToken().getText() !== '=') return; + + if (n.getRight().getText() === node.getText()) { + nodes.push(n.getRight()); + return nodes; + } + }); + + return nodes; +} + function getNodeLines(node: ts.Node, pathStr: string) { const refFullLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1].trim(); return `${pathStr}:${node.getStartLineNumber()}:\n ${refFullLine}`; } -function isCloned(node: ts.Node) { - const callParent = node.getParentIfKind(ts.SyntaxKind.CallExpression); - const expr = callParent?.getExpressionIfKind(ts.SyntaxKind.Identifier); - return callParent && expr?.getText() === 'clone'; +function checkFunctionArgs(node: ts.Node, methodBody: ts.Node, pathStr: string) { + const calls = methodBody.getDescendantsOfKind(ts.SyntaxKind.CallExpression); + + calls.forEach((c) => { + c.getArguments().forEach((a) => { + if (a.getText() === node.getText()) { + const callParent = a.getParentIfKind(ts.SyntaxKind.CallExpression); + const expr = callParent?.getExpressionIfKind(ts.SyntaxKind.Identifier); + + if (callParent && expr?.getText() === 'clone') { + return; + } + + throw Error( + `Cannot pass reference to a function. Use clone to create a deep copy: clone(${node.getText()})\n${getNodeLines( + a, + pathStr + )}` + ); + } + }); + }); } export function checkRefs(file: ts.SourceFile, pathStr: string) { @@ -125,27 +159,14 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { }); mutableValues.forEach((n) => { + checkFunctionArgs(n, body, pathStr); const accessNodes = arrayOrObjAccess(n, body); - accessNodes.forEach((a) => { - if ( - a.getParentIfKind(ts.SyntaxKind.CallExpression) && - !isCloned(a) && - !AVM_OBJECT_TYPES.includes(a.getType().getText()) - ) { - throw Error( - `Cannot pass reference to a function. Use clone to create a deep copy: clone(${n.getText()})\n${getNodeLines( - a, - pathStr - )}` - ); - } - }); - const referenceNodes = [ ...referencesInArrayLiteral(n, body), ...referencesInObjectLiteral(n, body), ...referencesInVariableDeclaration(n, body), + ...referencesInAssignment(n, body), ].filter((r) => !AVM_OBJECT_TYPES.includes(r.getType().getText())); referenceNodes.forEach((ref) => { diff --git a/tests/contracts/reference_compile_errors.algo.ts b/tests/contracts/reference_compile_errors.algo.ts deleted file mode 100644 index f56200983..000000000 --- a/tests/contracts/reference_compile_errors.algo.ts +++ /dev/null @@ -1,68 +0,0 @@ -import { Contract } from '../../src/lib/index'; - -type ArrObj = { - arr: uint64[]; -}; - -export class MutableRefInObjLiteral extends Contract { - mutableRefInObj() { - const arr: uint64[] = [1, 2, 3]; - - const arrObj: ArrObj = { arr: arr }; - - arr[0] = 4; - arrObj.arr[0] = 5; - - assert(arr[0] === arrObj.arr[0]); - } -} - -export class MutableRefInObjAssignment extends Contract { - mutableRefInObj() { - const arr: uint64[] = [1, 2, 3]; - - const arrObj: ArrObj = { arr: [] as uint64[] }; - - arrObj.arr = arr; - - arr[0] = 4; - arrObj.arr[0] = 5; - - assert(arr[0] === arrObj.arr[0]); - } -} - -export class MutableRefInArrayLiteral extends Contract { - mutableRefInArray() { - const arr: uint64[] = [1, 2, 3]; - const arrArr: uint64[][] = [arr]; - - arr[0] = 4; - arrArr[0][0] = 5; - - assert(arr[0] === arrArr[0][0]); - } -} - -export class MutableRefInArrayAssignment extends Contract { - mutableRefInArray() { - const arr: uint64[] = [1, 2, 3]; - const arrArr: uint64[][] = []; - arrArr[0] = arr; - - arr[0] = 4; - arrArr[0][0] = 5; - } -} - -export class MutableRefInPush extends Contract { - mutableRefInPush() { - const arr: uint64[] = [1, 2, 3]; - const arrArr: uint64[][] = []; - arrArr.push(arr); - arr[0] = 4; - arrArr[0][0] = 5; - - assert(arr[0] === arrArr[0][0]); - } -} diff --git a/tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts b/tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts new file mode 100644 index 000000000..35ff45167 --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts @@ -0,0 +1,12 @@ +import { Contract } from '../../../src/lib/index'; + +export class MutableRefInArrayAssignment extends Contract { + mutableRefInArray() { + const arr: uint64[] = [1, 2, 3]; + const arrArr: uint64[][] = [arr]; + + arrArr[0] = arr; + + assert(arr[0] === arrArr[0][0]); + } +} diff --git a/tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts b/tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts new file mode 100644 index 000000000..d28d4646c --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts @@ -0,0 +1,13 @@ +import { Contract } from '../../../src/lib/index'; + +export class MutableRefInArrayLiteral extends Contract { + mutableRefInArray() { + const arr: uint64[] = [1, 2, 3]; + const arrArr: uint64[][] = [arr]; + + arr[0] = 4; + arrArr[0][0] = 5; + + assert(arr[0] === arrArr[0][0]); + } +} diff --git a/tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts b/tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts new file mode 100644 index 000000000..42b48c9eb --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts @@ -0,0 +1,20 @@ +import { Contract } from '../../../src/lib/index'; + +type ArrObj = { + arr: uint64[]; +}; + +export class MutableRefInObjAssignment extends Contract { + mutableRefInObj() { + const arr: uint64[] = [1, 2, 3]; + + const arrObj: ArrObj = { arr: [] as uint64[] }; + + arrObj.arr = arr; + + arr[0] = 4; + arrObj.arr[0] = 5; + + assert(arr[0] === arrObj.arr[0]); + } +} diff --git a/tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts b/tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts new file mode 100644 index 000000000..81b378b1c --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts @@ -0,0 +1,18 @@ +import { Contract } from '../../../src/lib/index'; + +type ArrObj = { + arr: uint64[]; +}; + +export class MutableRefInObjLiteral extends Contract { + mutableRefInObj() { + const arr: uint64[] = [1, 2, 3]; + + const arrObj: ArrObj = { arr: arr }; + + arr[0] = 4; + arrObj.arr[0] = 5; + + assert(arr[0] === arrObj.arr[0]); + } +} diff --git a/tests/contracts/reference_errors/MutableRefInPush.algo.ts b/tests/contracts/reference_errors/MutableRefInPush.algo.ts new file mode 100644 index 000000000..3f78c0f3d --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInPush.algo.ts @@ -0,0 +1,13 @@ +import { Contract } from '../../../src/lib/index'; + +export class MutableRefInPush extends Contract { + mutableRefInPush() { + const arr: uint64[] = [1, 2, 3]; + const arrArr: uint64[][] = []; + arrArr.push(arr); + arr[0] = 4; + arrArr[0][0] = 5; + + assert(arr[0] === arrArr[0][0]); + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 4cad9fae7..5b60fe358 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -2,32 +2,56 @@ import { describe, test, expect } from '@jest/globals'; import algosdk from 'algosdk'; import { compileAndCreate } from './common'; -const ARTIFACTS_DIR = 'tests/contracts/artifacts/'; +const ARTIFACTS_DIR = 'tests/contracts/artifacts'; -function compilerErrorTest(contractName: string, errorMsg: string) { +function compilerErrorTest(contractName: string, errorMsg: string, line: string) { test(contractName, async () => { let msg: string; try { await compileAndCreate( algosdk.generateAccount(), - 'tests/contracts/reference_compile_errors.algo.ts', + `tests/contracts/reference_errors/${contractName}.algo.ts`, ARTIFACTS_DIR, contractName ); msg = 'No error'; // eslint-disable-next-line @typescript-eslint/no-explicit-any } catch (e: any) { + if (!(e.message as string).match(errorMsg)) { + throw e; + } msg = e.message; } expect(msg).toMatch(errorMsg); + expect(msg).toMatch(line); }); } describe('Reference Compile Errors', () => { - compilerErrorTest('MutableRefInObjLiteral', 'Cannot access or create a reference to an mutable type'); - compilerErrorTest('MutableRefInObjAssignment', 'Cannot access or create a reference to an mutable type'); - compilerErrorTest('MutableRefInArrayLiteral', 'Cannot access or create a reference to an mutable type'); - compilerErrorTest('MutableRefInArrayAssignment', 'Cannot access or create a reference to an mutable type'); - compilerErrorTest('MutableRefInPush', 'Cannot access or create a reference to an mutable type'); + compilerErrorTest( + 'MutableRefInObjLiteral', + 'Cannot access or create a reference to an mutable type', + 'const arrObj: ArrObj = { arr: arr }' + ); + + compilerErrorTest( + 'MutableRefInObjAssignment', + 'Cannot access or create a reference to an mutable type', + 'arrObj.arr = arr' + ); + + compilerErrorTest('MutableRefInArrayLiteral', 'Cannot access or create a reference to an mutable type', 'arr[0] = 4'); + + compilerErrorTest( + 'MutableRefInArrayAssignment', + 'Cannot access or create a reference to an mutable type', + 'arrArr[0] = arr' + ); + + compilerErrorTest( + 'MutableRefInPush', + 'Cannot pass reference to a function. Use clone to create a deep copy', + 'arrArr.push(arr)' + ); }); From a8ba20c52f8b5ccf08d6c18870b0401bcdfa19e1 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Fri, 11 Apr 2025 17:59:34 -0400 Subject: [PATCH 07/29] wip: MutableRefInVariableDeclaration --- src/lib/ref_checker.ts | 16 ++++++++++++---- .../MutableRefInVariableDeclaration.algo.ts | 13 +++++++++++++ tests/references.test.ts | 6 ++++++ 3 files changed, 31 insertions(+), 4 deletions(-) create mode 100644 tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 7277ca503..5f4a8a0d1 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -82,12 +82,20 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { methodBody.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression).forEach((n) => { if (n.getOperatorToken().getText() !== '=') return; - if (n.getRight().getText() === node.getText()) { - nodes.push(n.getRight()); - return nodes; - } + [n.getRight(), n.getLeft()].forEach((s) => { + if (s.getText() === node.getText()) { + nodes.push(s); + } + }); }); + methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { + const val = n.getInitializer(); + + if (val?.getText() === node.getText()) { + nodes.push(val); + } + }); return nodes; } diff --git a/tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts b/tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts new file mode 100644 index 000000000..c5a13b010 --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts @@ -0,0 +1,13 @@ +import { Contract } from '../../../src/lib/index'; + +export class MutableRefInVariableDeclaration extends Contract { + mutableRefInVariableDeclaration() { + const arrArr: uint64[][] = [[1, 2, 3]]; + + const x = arrArr[0]; + + arrArr[0][0] = 7; // <-- Error here because the canonical reference to arrArr[0] is now x + + assert(x[0] === 7); + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 5b60fe358..7456cfd2e 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -54,4 +54,10 @@ describe('Reference Compile Errors', () => { 'Cannot pass reference to a function. Use clone to create a deep copy', 'arrArr.push(arr)' ); + + compilerErrorTest( + 'MutableRefInVariableDeclaration', + 'Cannot access or create a reference to an mutable type ', + 'arrArr[0][0] = 7;' + ); }); From f7e052129a83faecb872ad83e34702536362b989 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Fri, 11 Apr 2025 20:07:33 -0400 Subject: [PATCH 08/29] wip: MutableRefInVariableDeclarationWithDynamicIndex --- src/lib/ref_checker.ts | 87 +++++++++++++++++-- ...ariableDeclarationWithDynamicIndex.algo.ts | 14 +++ tests/references.test.ts | 10 ++- 3 files changed, 100 insertions(+), 11 deletions(-) create mode 100644 tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 5f4a8a0d1..67c929ba7 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -1,6 +1,42 @@ import * as ts from 'ts-morph'; import { getExpressionChain } from './utils'; +/** Compare two nodes to see if they both access the same data */ +function nodesAccessSameData(aNode: ts.Node, bNode: ts.Node): boolean { + if (aNode === bNode) return false; + if (aNode.getText() === bNode.getText()) return true; + + let aChain: ts.Node[]; + let bChain: ts.Node[]; + + if (aNode.isKind(ts.SyntaxKind.ElementAccessExpression) || aNode.isKind(ts.SyntaxKind.PropertyAccessExpression)) { + const chain = getExpressionChain(aNode); + aChain = [chain.base, ...chain.chain]; + } else { + aChain = [aNode]; + } + + if (bNode.isKind(ts.SyntaxKind.ElementAccessExpression) || bNode.isKind(ts.SyntaxKind.ElementAccessExpression)) { + const chain = getExpressionChain(bNode); + bChain = [chain.base, ...chain.chain]; + } else { + bChain = [bNode]; + } + + const aTextChain = aChain.map((a) => a.getText()); + const bTextChain = bChain.map((b) => b.getText()); + + const hasMatch = + aTextChain.some((a) => { + return bTextChain.includes(a); + }) || + bTextChain.some((b) => { + return aTextChain.includes(b); + }); + + return hasMatch; +} + /** Expressions that access (read or write) the array */ function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { const elementExpr = methodBody.getDescendantsOfKind(ts.SyntaxKind.ElementAccessExpression); @@ -11,7 +47,7 @@ function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { const chain = getExpressionChain(n); [chain.base, ...chain.chain].forEach((e) => { - if (e.getText() === node.getText() && e.getPos() !== node.getPos()) { + if (nodesAccessSameData(e, node)) { nodes.push(e); } }); @@ -26,7 +62,7 @@ function referencesInArrayLiteral(node: ts.Node, methodBody: ts.Node) { methodBody.getDescendantsOfKind(ts.SyntaxKind.ArrayLiteralExpression).forEach((n) => { n.getElements().forEach((e) => { - if (e.getText() === node.getText() && e !== node) { + if (nodesAccessSameData(e, node)) { nodes.push(e); } }); @@ -44,7 +80,7 @@ function referencesInObjectLiteral(node: ts.Node, methodBody: ts.Node) { // TODO: Support short-hand if (!e.isKind(ts.SyntaxKind.PropertyAssignment)) throw new Error(); const value = e.getInitializer(); - if (value?.getText() === node.getText() && value !== node) { + if (value && nodesAccessSameData(node, value)) { nodes.push(value); } }); @@ -67,7 +103,7 @@ function referencesInVariableDeclaration(node: ts.Node, methodBody: ts.Node) { return; } - if (val?.getText() === node.getText() && val !== node) { + if (val && nodesAccessSameData(val, node)) { nodes.push(val); } }); @@ -83,7 +119,7 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { if (n.getOperatorToken().getText() !== '=') return; [n.getRight(), n.getLeft()].forEach((s) => { - if (s.getText() === node.getText()) { + if (nodesAccessSameData(s, node)) { nodes.push(s); } }); @@ -92,10 +128,11 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { const val = n.getInitializer(); - if (val?.getText() === node.getText()) { + if (val && nodesAccessSameData(val, node)) { nodes.push(val); } }); + return nodes; } @@ -110,7 +147,7 @@ function checkFunctionArgs(node: ts.Node, methodBody: ts.Node, pathStr: string) calls.forEach((c) => { c.getArguments().forEach((a) => { - if (a.getText() === node.getText()) { + if (nodesAccessSameData(a, node)) { const callParent = a.getParentIfKind(ts.SyntaxKind.CallExpression); const expr = callParent?.getExpressionIfKind(ts.SyntaxKind.Identifier); @@ -129,6 +166,35 @@ function checkFunctionArgs(node: ts.Node, methodBody: ts.Node, pathStr: string) }); } +/** Given a node, return the non-dynamic chain. For example, `arr[0][i]` returns `arr[0]`. + * This is required because we want to be pessimistic about dynamic array access + * */ +function getNonDynamicNode(node: ts.Node): ts.Node { + if (!node.isKind(ts.SyntaxKind.ElementAccessExpression) && !node.isKind(ts.SyntaxKind.CallExpression)) { + return node; + } + + const chain = getExpressionChain(node); + let currentNode = chain.base; + let foundDynamic = false; + + chain.chain.forEach((e) => { + if (foundDynamic) return; + if (!e.isKind(ts.SyntaxKind.ElementAccessExpression)) { + currentNode = e; + return; + } + + const arg = e.getArgumentExpression()?.getText() ?? Number.NaN; + + if (Number.isNaN(Number(arg))) { + foundDynamic = true; + } + }); + + return currentNode; +} + export function checkRefs(file: ts.SourceFile, pathStr: string) { file.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration).forEach((m) => { const body = m.getBody()!; @@ -139,6 +205,7 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { ...body.getDescendantsOfKind(ts.SyntaxKind.ElementAccessExpression), ] .filter((n) => n.getType().isArray() || n.getType().isObject()) + .map(getNonDynamicNode) .filter((n) => { if (n.isKind(ts.SyntaxKind.Identifier)) { const callParent = n.getFirstAncestorByKind(ts.SyntaxKind.CallExpression); @@ -168,14 +235,16 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { mutableValues.forEach((n) => { checkFunctionArgs(n, body, pathStr); - const accessNodes = arrayOrObjAccess(n, body); + const accessNodes = arrayOrObjAccess(n, body).map(getNonDynamicNode); const referenceNodes = [ ...referencesInArrayLiteral(n, body), ...referencesInObjectLiteral(n, body), ...referencesInVariableDeclaration(n, body), ...referencesInAssignment(n, body), - ].filter((r) => !AVM_OBJECT_TYPES.includes(r.getType().getText())); + ] + .filter((r) => !AVM_OBJECT_TYPES.includes(r.getType().getText())) + .map(getNonDynamicNode); referenceNodes.forEach((ref) => { const violator = [...referenceNodes, ...accessNodes].find((v) => v.getPos() > ref.getPos()); diff --git a/tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts b/tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts new file mode 100644 index 000000000..33dc38c9f --- /dev/null +++ b/tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts @@ -0,0 +1,14 @@ +import { Contract } from '../../../src/lib/index'; + +export class MutableRefInVariableDeclarationWithDynamicIndex extends Contract { + mutableRefInVariableDeclaration() { + const arrArr: uint64[][] = [[1, 2, 3]]; + + const i = 0; + const x = arrArr[i]; + + arrArr[0][0] = 7; // <-- Error here because the canonical reference to arrArr is now x (because of dynamic index) + + assert(x[0] === 7); + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 7456cfd2e..bb0b7dd62 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -57,7 +57,13 @@ describe('Reference Compile Errors', () => { compilerErrorTest( 'MutableRefInVariableDeclaration', - 'Cannot access or create a reference to an mutable type ', - 'arrArr[0][0] = 7;' + 'Cannot access or create a reference to an mutable type', + 'arrArr[0][0] = 7' + ); + + compilerErrorTest( + 'MutableRefInVariableDeclarationWithDynamicIndex', + 'Cannot access or create a reference to an mutable type', + 'arrArr[0][0] = 7' ); }); From 36e447d01cf0eea276067ab2e7ac3f6717f7c94a Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Fri, 11 Apr 2025 21:23:55 -0400 Subject: [PATCH 09/29] wip: fix some of the false positives ensures we only count references in an array when the value is mutable. Also accounts for state values --- src/lib/ref_checker.ts | 35 +++++++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 8 deletions(-) diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 67c929ba7..8f7531196 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -56,12 +56,24 @@ function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { return nodes; } +const AVM_OBJECT_TYPES = ['Address', 'AppID', 'AssetID']; + +function isArrayOrObject(node: ts.Node) { + const type = node.getType(); + const typeText = type.getText(); + + if (AVM_OBJECT_TYPES.includes(typeText)) return false; + + return type.isArray() || type.isObject(); +} + /** References to the node created in an array literal expression */ function referencesInArrayLiteral(node: ts.Node, methodBody: ts.Node) { const nodes: ts.Node[] = []; methodBody.getDescendantsOfKind(ts.SyntaxKind.ArrayLiteralExpression).forEach((n) => { n.getElements().forEach((e) => { + if (!isArrayOrObject(e)) return; if (nodesAccessSameData(e, node)) { nodes.push(e); } @@ -80,6 +92,7 @@ function referencesInObjectLiteral(node: ts.Node, methodBody: ts.Node) { // TODO: Support short-hand if (!e.isKind(ts.SyntaxKind.PropertyAssignment)) throw new Error(); const value = e.getInitializer(); + if (value && !isArrayOrObject(value)) return; if (value && nodesAccessSameData(node, value)) { nodes.push(value); } @@ -89,8 +102,6 @@ function referencesInObjectLiteral(node: ts.Node, methodBody: ts.Node) { return nodes; } -const AVM_OBJECT_TYPES = ['Address', 'AppID', 'AssetID']; - /** References to the node created by a variable declaration */ function referencesInVariableDeclaration(node: ts.Node, methodBody: ts.Node) { const nodes: ts.Node[] = []; @@ -118,11 +129,9 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { methodBody.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression).forEach((n) => { if (n.getOperatorToken().getText() !== '=') return; - [n.getRight(), n.getLeft()].forEach((s) => { - if (nodesAccessSameData(s, node)) { - nodes.push(s); - } - }); + if (nodesAccessSameData(n.getRight(), node)) { + nodes.push(n.getRight()); + } }); methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { @@ -139,7 +148,9 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { function getNodeLines(node: ts.Node, pathStr: string) { const refFullLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1].trim(); - return `${pathStr}:${node.getStartLineNumber()}:\n ${refFullLine}`; + return `${pathStr}:${node.getStartLineNumber()}:${ + ts.ts.getLineAndCharacterOfPosition(node.getSourceFile().compilerNode, node.getPos()).character + }\n ${refFullLine}`; } function checkFunctionArgs(node: ts.Node, methodBody: ts.Node, pathStr: string) { @@ -195,6 +206,7 @@ function getNonDynamicNode(node: ts.Node): ts.Node { return currentNode; } +const TEALSCRIPT_STATE_TYPES = ['GlobalStateValue', 'BoxValue']; export function checkRefs(file: ts.SourceFile, pathStr: string) { file.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration).forEach((m) => { const body = m.getBody()!; @@ -207,6 +219,13 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { .filter((n) => n.getType().isArray() || n.getType().isObject()) .map(getNonDynamicNode) .filter((n) => { + if (AVM_OBJECT_TYPES.includes(n.getType().getText())) return false; + + // eslint-disable-next-line + for (const t of TEALSCRIPT_STATE_TYPES) { + if (n.getType().getText().startsWith(`${t}<`)) return false; + } + if (n.isKind(ts.SyntaxKind.Identifier)) { const callParent = n.getFirstAncestorByKind(ts.SyntaxKind.CallExpression); const expr = callParent?.getExpression(); From 31f4c7f8e60484aeab9ffa52a263a55f506c0a63 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 05:49:56 -0400 Subject: [PATCH 10/29] wip: treat function args like other references --- scripts/compile_all.ts | 1 + src/lib/ref_checker.ts | 42 ++++++++++++++++-------------------------- 2 files changed, 17 insertions(+), 26 deletions(-) diff --git a/scripts/compile_all.ts b/scripts/compile_all.ts index efd03f730..a2630bd80 100644 --- a/scripts/compile_all.ts +++ b/scripts/compile_all.ts @@ -22,6 +22,7 @@ const examplesArtifacts = { async function main() { const files = globSync(path.join(__dirname, '../**/*.algo.ts')); files.forEach((file) => { + if (file.includes('reference_errors')) return; if (file.includes('compile_errors')) return; const isExample = file.includes('examples/'); const project = isExample ? EXAMPLES_PROJECT : TESTS_PROJECT; diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 8f7531196..8928601ea 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -56,7 +56,7 @@ function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { return nodes; } -const AVM_OBJECT_TYPES = ['Address', 'AppID', 'AssetID']; +const AVM_OBJECT_TYPES = ['Address', 'AppID', 'AssetID', 'ECDSAPubKey', 'Txn[]']; function isArrayOrObject(node: ts.Node) { const type = node.getType(); @@ -145,6 +145,20 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { return nodes; } +function referencesInFunctionCalls(node: ts.Node, methodBody: ts.Node): ts.Node[] { + const nodes: ts.Node[] = []; + methodBody.getDescendantsOfKind(ts.SyntaxKind.CallExpression).forEach((n) => { + n.getArguments().forEach((a) => { + if (!isArrayOrObject(a)) return; + if (nodesAccessSameData(a, node)) { + nodes.push(a); + } + }); + }); + + return nodes; +} + function getNodeLines(node: ts.Node, pathStr: string) { const refFullLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1].trim(); @@ -153,30 +167,6 @@ function getNodeLines(node: ts.Node, pathStr: string) { }\n ${refFullLine}`; } -function checkFunctionArgs(node: ts.Node, methodBody: ts.Node, pathStr: string) { - const calls = methodBody.getDescendantsOfKind(ts.SyntaxKind.CallExpression); - - calls.forEach((c) => { - c.getArguments().forEach((a) => { - if (nodesAccessSameData(a, node)) { - const callParent = a.getParentIfKind(ts.SyntaxKind.CallExpression); - const expr = callParent?.getExpressionIfKind(ts.SyntaxKind.Identifier); - - if (callParent && expr?.getText() === 'clone') { - return; - } - - throw Error( - `Cannot pass reference to a function. Use clone to create a deep copy: clone(${node.getText()})\n${getNodeLines( - a, - pathStr - )}` - ); - } - }); - }); -} - /** Given a node, return the non-dynamic chain. For example, `arr[0][i]` returns `arr[0]`. * This is required because we want to be pessimistic about dynamic array access * */ @@ -253,7 +243,6 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { }); mutableValues.forEach((n) => { - checkFunctionArgs(n, body, pathStr); const accessNodes = arrayOrObjAccess(n, body).map(getNonDynamicNode); const referenceNodes = [ @@ -261,6 +250,7 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { ...referencesInObjectLiteral(n, body), ...referencesInVariableDeclaration(n, body), ...referencesInAssignment(n, body), + ...referencesInFunctionCalls(n, body), ] .filter((r) => !AVM_OBJECT_TYPES.includes(r.getType().getText())) .map(getNonDynamicNode); From 6154aab689f74fc0644151abedaf1556f26e2dfe Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 06:32:01 -0400 Subject: [PATCH 11/29] wip: simplify access check --- examples/reti/validatorRegistry.algo.ts | 4 ++-- src/lib/ref_checker.ts | 26 ++++++++++--------------- tests/references.test.ts | 6 +----- 3 files changed, 13 insertions(+), 23 deletions(-) diff --git a/examples/reti/validatorRegistry.algo.ts b/examples/reti/validatorRegistry.algo.ts index fbb3421d3..6bd7d5d17 100644 --- a/examples/reti/validatorRegistry.algo.ts +++ b/examples/reti/validatorRegistry.algo.ts @@ -693,12 +693,12 @@ export class ValidatorRegistry extends Contract { } // Update StakerPoolList for this found pool (new or existing) - this.updateStakerPoolSet(staker, poolKey); + this.updateStakerPoolSet(staker, clone(poolKey)); // Send the callers algo amount (- mbrAmtLeftBehind) to the specified staking pool, and it then updates // the staker data. this.callPoolAddStake( stakedAmountPayment, - poolKey, + clone(poolKey), mbrAmtLeftBehind, isNewStakerToValidator, isNewStakerToProtocol diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 8928601ea..57d80a2a2 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -38,21 +38,15 @@ function nodesAccessSameData(aNode: ts.Node, bNode: ts.Node): boolean { } /** Expressions that access (read or write) the array */ -function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node) { - const elementExpr = methodBody.getDescendantsOfKind(ts.SyntaxKind.ElementAccessExpression); - const propExpr = methodBody.getDescendantsOfKind(ts.SyntaxKind.PropertyAccessExpression); - +function arrayOrObjAccess(node: ts.Node, methodBody: ts.Node, references: ts.Node[]) { const nodes: ts.Node[] = []; - [...elementExpr, ...propExpr].forEach((n) => { - const chain = getExpressionChain(n); - [chain.base, ...chain.chain].forEach((e) => { - if (nodesAccessSameData(e, node)) { - nodes.push(e); - } - }); + methodBody.getDescendantsOfKind(node.getKind()).forEach((n) => { + if (!isArrayOrObject(n)) return; + if (nodesAccessSameData(n, node) && !references.includes(n)) { + nodes.push(n); + } }); - return nodes; } @@ -129,7 +123,7 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { methodBody.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression).forEach((n) => { if (n.getOperatorToken().getText() !== '=') return; - if (nodesAccessSameData(n.getRight(), node)) { + if (isArrayOrObject(n.getRight()) && nodesAccessSameData(n.getRight(), node)) { nodes.push(n.getRight()); } }); @@ -137,7 +131,7 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { const val = n.getInitializer(); - if (val && nodesAccessSameData(val, node)) { + if (val && isArrayOrObject(val) && nodesAccessSameData(val, node)) { nodes.push(val); } }); @@ -150,6 +144,7 @@ function referencesInFunctionCalls(node: ts.Node, methodBody: ts.Node): ts.Node[ methodBody.getDescendantsOfKind(ts.SyntaxKind.CallExpression).forEach((n) => { n.getArguments().forEach((a) => { if (!isArrayOrObject(a)) return; + if (n.getExpression().getText() === 'clone') return; if (nodesAccessSameData(a, node)) { nodes.push(a); } @@ -243,8 +238,6 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { }); mutableValues.forEach((n) => { - const accessNodes = arrayOrObjAccess(n, body).map(getNonDynamicNode); - const referenceNodes = [ ...referencesInArrayLiteral(n, body), ...referencesInObjectLiteral(n, body), @@ -255,6 +248,7 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { .filter((r) => !AVM_OBJECT_TYPES.includes(r.getType().getText())) .map(getNonDynamicNode); + const accessNodes = arrayOrObjAccess(n, body, referenceNodes).map(getNonDynamicNode); referenceNodes.forEach((ref) => { const violator = [...referenceNodes, ...accessNodes].find((v) => v.getPos() > ref.getPos()); diff --git a/tests/references.test.ts b/tests/references.test.ts index bb0b7dd62..03bcd7973 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -49,11 +49,7 @@ describe('Reference Compile Errors', () => { 'arrArr[0] = arr' ); - compilerErrorTest( - 'MutableRefInPush', - 'Cannot pass reference to a function. Use clone to create a deep copy', - 'arrArr.push(arr)' - ); + compilerErrorTest('MutableRefInPush', 'Cannot access or create a reference to an mutable type', 'arr[0] = 4'); compilerErrorTest( 'MutableRefInVariableDeclaration', From 3a9d9a2bd1f05599d9d1f84de67da3332b3452c2 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 07:13:55 -0400 Subject: [PATCH 12/29] wip: rm variable decl check because it's supported by TEALScript --- examples/tuple_in_box/app.algo.ts | 2 +- src/lib/ref_checker.ts | 29 - tests/abi.test.ts | 5 + tests/contracts/abi.algo.ts | 15 + ...ableRefInVariableDeclaration.approval.teal | 178 +++ ...MutableRefInVariableDeclaration.arc32.json | 65 + ...tMutableRefInVariableDeclaration.arc4.json | 20 + ...MutableRefInVariableDeclaration.arc56.json | 1107 +++++++++++++++++ ...MutableRefInVariableDeclaration.clear.teal | 1 + .../MutableRefInVariableDeclaration.algo.ts | 13 - ...ariableDeclarationWithDynamicIndex.algo.ts | 14 - tests/references.test.ts | 12 - 12 files changed, 1392 insertions(+), 69 deletions(-) create mode 100644 tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.approval.teal create mode 100644 tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc32.json create mode 100644 tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc4.json create mode 100644 tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc56.json create mode 100644 tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.clear.teal delete mode 100644 tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts delete mode 100644 tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts diff --git a/examples/tuple_in_box/app.algo.ts b/examples/tuple_in_box/app.algo.ts index 206dd2f5d..fdcb4a41f 100644 --- a/examples/tuple_in_box/app.algo.ts +++ b/examples/tuple_in_box/app.algo.ts @@ -11,7 +11,7 @@ class ContactsApp extends Contract { setMyContact(name: string, company: string): void { const contact: Contact = { name: name, company: company }; - this.myContact.value = contact; + this.myContact.value = clone(contact); this.contacts(this.txn.sender).value = contact; } diff --git a/src/lib/ref_checker.ts b/src/lib/ref_checker.ts index 57d80a2a2..21ea6315b 100644 --- a/src/lib/ref_checker.ts +++ b/src/lib/ref_checker.ts @@ -96,26 +96,6 @@ function referencesInObjectLiteral(node: ts.Node, methodBody: ts.Node) { return nodes; } -/** References to the node created by a variable declaration */ -function referencesInVariableDeclaration(node: ts.Node, methodBody: ts.Node) { - const nodes: ts.Node[] = []; - - methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { - const val = n.getInitializer(); - const valType = val?.getType(); - - if (!valType?.isArray() && !valType?.isObject()) { - return; - } - - if (val && nodesAccessSameData(val, node)) { - nodes.push(val); - } - }); - - return nodes; -} - /** References to the node in value assignment */ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { const nodes: ts.Node[] = []; @@ -128,14 +108,6 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { } }); - methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((n) => { - const val = n.getInitializer(); - - if (val && isArrayOrObject(val) && nodesAccessSameData(val, node)) { - nodes.push(val); - } - }); - return nodes; } @@ -241,7 +213,6 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { const referenceNodes = [ ...referencesInArrayLiteral(n, body), ...referencesInObjectLiteral(n, body), - ...referencesInVariableDeclaration(n, body), ...referencesInAssignment(n, body), ...referencesInFunctionCalls(n, body), ] diff --git a/tests/abi.test.ts b/tests/abi.test.ts index 5868dc667..506a1197d 100644 --- a/tests/abi.test.ts +++ b/tests/abi.test.ts @@ -980,4 +980,9 @@ describe('ABI', function () { expect(await runMethod(appClient, 'boolUpdateInObjectInBox')).toEqual(true); }); + test('mutableRefInVariableDeclaration', async () => { + const { appClient } = await compileAndCreate('mutableRefInVariableDeclaration'); + + expect(await runMethod(appClient, 'mutableRefInVariableDeclaration')).toEqual([7n, 8n]); + }); }); diff --git a/tests/contracts/abi.algo.ts b/tests/contracts/abi.algo.ts index 0002bfcaa..adfd20f2e 100644 --- a/tests/contracts/abi.algo.ts +++ b/tests/contracts/abi.algo.ts @@ -1727,3 +1727,18 @@ class ABITestBoolUpdateInObjectInBox extends Contract { return this.boxes('bRef').value.bool; } } + +export class ABITestMutableRefInVariableDeclaration extends Contract { + mutableRefInVariableDeclaration(): [uint64, uint64] { + const arrArr: uint64[][] = [[1, 2, 3]]; + + const x = arrArr[0]; + + arrArr[0][0] = 7; + + const y = arrArr[0]; + y[1] = 8; + + return [x[0], arrArr[0][1]]; + } +} diff --git a/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.approval.teal b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.approval.teal new file mode 100644 index 000000000..77eed4aef --- /dev/null +++ b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.approval.teal @@ -0,0 +1,178 @@ +#pragma version 10 +intcblock 2 8 0 1 +bytecblock 0x + +// This TEAL was generated by TEALScript v0.106.3 +// https://github.com/algorandfoundation/TEALScript + +// This contract is compliant with and/or implements the following ARCs: [ ARC4 ] + +// The following ten lines of TEAL handle initial program flow +// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed +// Here, action refers to the OnComplete in combination with whether the app is being created or called +// Every possible action for this contract is represented in the switch statement +// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err" +txn ApplicationID +! +pushint 6 +* +txn OnCompletion ++ +switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED + +*NOT_IMPLEMENTED: + // The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID? + err + +// mutableRefInVariableDeclaration()(uint64,uint64) +*abi_route_mutableRefInVariableDeclaration: + // The ABI return prefix + pushbytes 0x151f7c75 + + // execute mutableRefInVariableDeclaration()(uint64,uint64) + callsub mutableRefInVariableDeclaration + concat + log + intc 3 // 1 + return + +// mutableRefInVariableDeclaration(): [uint64, uint64] +mutableRefInVariableDeclaration: + proto 0 1 + + // Push empty bytes after the frame pointer to reserve space for local variables + bytec 0 // 0x + + // tests/contracts/abi.algo.ts:1733 + // arrArr: uint64[][] = [[1, 2, 3]] + bytec 0 // initial head + bytec 0 // initial tail + pushbytes 0x0002 // initial head offset + pushbytes 0x0003000000000000000100000000000000020000000000000003 + callsub *process_dynamic_tuple_element + pop // pop head offset + concat // concat head and tail + pushbytes 0x0001 + swap + concat + frame_bury 0 // arrArr: uint64[][] + + // tests/contracts/abi.algo.ts:1735 + // x = arrArr[0] + // tests/contracts/abi.algo.ts:1737 + // arrArr[0][0] = 7 + frame_dig 0 // arrArr: uint64[][] + store 255 // full array + load 255 // full array + intc 0 // 2 + extract_uint16 + intc 2 // acc * typeLength + + + intc 0 // 2 + + // add two for length + load 255 // full array + swap + pushbytes 0x0000000000000007 + replace3 + frame_bury 0 // arrArr: uint64[][] + + // tests/contracts/abi.algo.ts:1739 + // y = arrArr[0] + // tests/contracts/abi.algo.ts:1740 + // y[1] = 8 + frame_dig 0 // arrArr: uint64[][] + store 255 // full array + load 255 // full array + intc 0 // 2 + extract_uint16 + intc 1 // acc * typeLength + + + intc 0 // 2 + + // add two for length + load 255 // full array + swap + pushbytes 0x0000000000000008 + replace3 + frame_bury 0 // y: uint64[][] + + // tests/contracts/abi.algo.ts:1742 + // return [x[0], arrArr[0][1]]; + frame_dig 0 // arrArr: uint64[][] + store 255 // full array + load 255 // full array + intc 0 // 2 + extract_uint16 + intc 2 // acc * typeLength + + + intc 0 // 2 + + // add two for length + load 255 // full array + swap + intc 1 // 8 + extract3 + btoi + itob + frame_dig 0 // arrArr: uint64[][] + store 255 // full array + load 255 // full array + intc 0 // 2 + extract_uint16 + intc 1 // acc * typeLength + + + intc 0 // 2 + + // add two for length + load 255 // full array + swap + intc 1 // 8 + extract3 + btoi + itob + concat + + // set the subroutine return value + frame_bury 0 + retsub + +*abi_route_createApplication: + intc 3 // 1 + return + +*create_NoOp: + pushbytes 0xb8447b36 // method "createApplication()void" + txna ApplicationArgs 0 + match *abi_route_createApplication + + // this contract does not implement the given ABI method for create NoOp + err + +*call_NoOp: + pushbytes 0xfa53386f // method "mutableRefInVariableDeclaration()(uint64,uint64)" + txna ApplicationArgs 0 + match *abi_route_mutableRefInVariableDeclaration + + // this contract does not implement the given ABI method for call NoOp + err + +*process_dynamic_tuple_element: + proto 4 3 + frame_dig -4 // tuple head + frame_dig -2 // head offset + concat + frame_bury -4 // tuple head + frame_dig -1 // element + dup + len + frame_dig -2 // head offset + btoi + + + itob + extract 6 2 + frame_bury -2 // head offset + frame_dig -3 // tuple tail + swap + concat + frame_bury -3 // tuple tail + frame_dig -4 // tuple head + frame_dig -3 // tuple tail + frame_dig -2 // head offset + retsub \ No newline at end of file diff --git a/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc32.json b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc32.json new file mode 100644 index 000000000..27538fa77 --- /dev/null +++ b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc32.json @@ -0,0 +1,65 @@ +{ + "hints": { + "mutableRefInVariableDeclaration()(uint64,uint64)": { + "call_config": { + "no_op": "CALL" + } + }, + "createApplication()void": { + "call_config": { + "no_op": "CREATE" + } + } + }, + "bare_call_config": { + "no_op": "NEVER", + "opt_in": "NEVER", + "close_out": "NEVER", + "update_application": "NEVER", + "delete_application": "NEVER" + }, + "schema": { + "local": { + "declared": {}, + "reserved": {} + }, + "global": { + "declared": {}, + "reserved": {} + } + }, + "state": { + "global": { + "num_byte_slices": 0, + "num_uints": 0 + }, + "local": { + "num_byte_slices": 0, + "num_uints": 0 + } + }, + "source": { + "approval": "I3ByYWdtYSB2ZXJzaW9uIDEwCmludGNibG9jayAyIDggMCAxCmJ5dGVjYmxvY2sgMHgKCi8vIFRoaXMgVEVBTCB3YXMgZ2VuZXJhdGVkIGJ5IFRFQUxTY3JpcHQgdjAuMTA2LjMKLy8gaHR0cHM6Ly9naXRodWIuY29tL2FsZ29yYW5kZm91bmRhdGlvbi9URUFMU2NyaXB0CgovLyBUaGlzIGNvbnRyYWN0IGlzIGNvbXBsaWFudCB3aXRoIGFuZC9vciBpbXBsZW1lbnRzIHRoZSBmb2xsb3dpbmcgQVJDczogWyBBUkM0IF0KCi8vIFRoZSBmb2xsb3dpbmcgdGVuIGxpbmVzIG9mIFRFQUwgaGFuZGxlIGluaXRpYWwgcHJvZ3JhbSBmbG93Ci8vIFRoaXMgcGF0dGVybiBpcyB1c2VkIHRvIG1ha2UgaXQgZWFzeSBmb3IgYW55b25lIHRvIHBhcnNlIHRoZSBzdGFydCBvZiB0aGUgcHJvZ3JhbSBhbmQgZGV0ZXJtaW5lIGlmIGEgc3BlY2lmaWMgYWN0aW9uIGlzIGFsbG93ZWQKLy8gSGVyZSwgYWN0aW9uIHJlZmVycyB0byB0aGUgT25Db21wbGV0ZSBpbiBjb21iaW5hdGlvbiB3aXRoIHdoZXRoZXIgdGhlIGFwcCBpcyBiZWluZyBjcmVhdGVkIG9yIGNhbGxlZAovLyBFdmVyeSBwb3NzaWJsZSBhY3Rpb24gZm9yIHRoaXMgY29udHJhY3QgaXMgcmVwcmVzZW50ZWQgaW4gdGhlIHN3aXRjaCBzdGF0ZW1lbnQKLy8gSWYgdGhlIGFjdGlvbiBpcyBub3QgaW1wbGVtZW50ZWQgaW4gdGhlIGNvbnRyYWN0LCBpdHMgcmVzcGVjdGl2ZSBicmFuY2ggd2lsbCBiZSAiKk5PVF9JTVBMRU1FTlRFRCIgd2hpY2gganVzdCBjb250YWlucyAiZXJyIgp0eG4gQXBwbGljYXRpb25JRAohCnB1c2hpbnQgNgoqCnR4biBPbkNvbXBsZXRpb24KKwpzd2l0Y2ggKmNhbGxfTm9PcCAqTk9UX0lNUExFTUVOVEVEICpOT1RfSU1QTEVNRU5URUQgKk5PVF9JTVBMRU1FTlRFRCAqTk9UX0lNUExFTUVOVEVEICpOT1RfSU1QTEVNRU5URUQgKmNyZWF0ZV9Ob09wICpOT1RfSU1QTEVNRU5URUQgKk5PVF9JTVBMRU1FTlRFRCAqTk9UX0lNUExFTUVOVEVEICpOT1RfSU1QTEVNRU5URUQgKk5PVF9JTVBMRU1FTlRFRAoKKk5PVF9JTVBMRU1FTlRFRDoKCS8vIFRoZSByZXF1ZXN0ZWQgYWN0aW9uIGlzIG5vdCBpbXBsZW1lbnRlZCBpbiB0aGlzIGNvbnRyYWN0LiBBcmUgeW91IHVzaW5nIHRoZSBjb3JyZWN0IE9uQ29tcGxldGU/IERpZCB5b3Ugc2V0IHlvdXIgYXBwIElEPwoJZXJyCgovLyBtdXRhYmxlUmVmSW5WYXJpYWJsZURlY2xhcmF0aW9uKCkodWludDY0LHVpbnQ2NCkKKmFiaV9yb3V0ZV9tdXRhYmxlUmVmSW5WYXJpYWJsZURlY2xhcmF0aW9uOgoJLy8gVGhlIEFCSSByZXR1cm4gcHJlZml4CglwdXNoYnl0ZXMgMHgxNTFmN2M3NQoKCS8vIGV4ZWN1dGUgbXV0YWJsZVJlZkluVmFyaWFibGVEZWNsYXJhdGlvbigpKHVpbnQ2NCx1aW50NjQpCgljYWxsc3ViIG11dGFibGVSZWZJblZhcmlhYmxlRGVjbGFyYXRpb24KCWNvbmNhdAoJbG9nCglpbnRjIDMgLy8gMQoJcmV0dXJuCgovLyBtdXRhYmxlUmVmSW5WYXJpYWJsZURlY2xhcmF0aW9uKCk6IFt1aW50NjQsIHVpbnQ2NF0KbXV0YWJsZVJlZkluVmFyaWFibGVEZWNsYXJhdGlvbjoKCXByb3RvIDAgMQoKCS8vIFB1c2ggZW1wdHkgYnl0ZXMgYWZ0ZXIgdGhlIGZyYW1lIHBvaW50ZXIgdG8gcmVzZXJ2ZSBzcGFjZSBmb3IgbG9jYWwgdmFyaWFibGVzCglieXRlYyAwIC8vIDB4CgoJLy8gdGVzdHMvY29udHJhY3RzL2FiaS5hbGdvLnRzOjE3MzMKCS8vIGFyckFycjogdWludDY0W11bXSA9IFtbMSwgMiwgM11dCglieXRlYyAwIC8vICBpbml0aWFsIGhlYWQKCWJ5dGVjIDAgLy8gIGluaXRpYWwgdGFpbAoJcHVzaGJ5dGVzIDB4MDAwMiAvLyBpbml0aWFsIGhlYWQgb2Zmc2V0CglwdXNoYnl0ZXMgMHgwMDAzMDAwMDAwMDAwMDAwMDAwMTAwMDAwMDAwMDAwMDAwMDIwMDAwMDAwMDAwMDAwMDAzCgljYWxsc3ViICpwcm9jZXNzX2R5bmFtaWNfdHVwbGVfZWxlbWVudAoJcG9wIC8vIHBvcCBoZWFkIG9mZnNldAoJY29uY2F0IC8vIGNvbmNhdCBoZWFkIGFuZCB0YWlsCglwdXNoYnl0ZXMgMHgwMDAxCglzd2FwCgljb25jYXQKCWZyYW1lX2J1cnkgMCAvLyBhcnJBcnI6IHVpbnQ2NFtdW10KCgkvLyB0ZXN0cy9jb250cmFjdHMvYWJpLmFsZ28udHM6MTczNQoJLy8geCA9IGFyckFyclswXQoJLy8gdGVzdHMvY29udHJhY3RzL2FiaS5hbGdvLnRzOjE3MzcKCS8vIGFyckFyclswXVswXSA9IDcKCWZyYW1lX2RpZyAwIC8vIGFyckFycjogdWludDY0W11bXQoJc3RvcmUgMjU1IC8vIGZ1bGwgYXJyYXkKCWxvYWQgMjU1IC8vIGZ1bGwgYXJyYXkKCWludGMgMCAvLyAyCglleHRyYWN0X3VpbnQxNgoJaW50YyAyIC8vICBhY2MgKiB0eXBlTGVuZ3RoCgkrCglpbnRjIDAgLy8gMgoJKyAvLyBhZGQgdHdvIGZvciBsZW5ndGgKCWxvYWQgMjU1IC8vIGZ1bGwgYXJyYXkKCXN3YXAKCXB1c2hieXRlcyAweDAwMDAwMDAwMDAwMDAwMDcKCXJlcGxhY2UzCglmcmFtZV9idXJ5IDAgLy8gYXJyQXJyOiB1aW50NjRbXVtdCgoJLy8gdGVzdHMvY29udHJhY3RzL2FiaS5hbGdvLnRzOjE3MzkKCS8vIHkgPSBhcnJBcnJbMF0KCS8vIHRlc3RzL2NvbnRyYWN0cy9hYmkuYWxnby50czoxNzQwCgkvLyB5WzFdID0gOAoJZnJhbWVfZGlnIDAgLy8gYXJyQXJyOiB1aW50NjRbXVtdCglzdG9yZSAyNTUgLy8gZnVsbCBhcnJheQoJbG9hZCAyNTUgLy8gZnVsbCBhcnJheQoJaW50YyAwIC8vIDIKCWV4dHJhY3RfdWludDE2CglpbnRjIDEgLy8gIGFjYyAqIHR5cGVMZW5ndGgKCSsKCWludGMgMCAvLyAyCgkrIC8vIGFkZCB0d28gZm9yIGxlbmd0aAoJbG9hZCAyNTUgLy8gZnVsbCBhcnJheQoJc3dhcAoJcHVzaGJ5dGVzIDB4MDAwMDAwMDAwMDAwMDAwOAoJcmVwbGFjZTMKCWZyYW1lX2J1cnkgMCAvLyB5OiB1aW50NjRbXVtdCgoJLy8gdGVzdHMvY29udHJhY3RzL2FiaS5hbGdvLnRzOjE3NDIKCS8vIHJldHVybiBbeFswXSwgYXJyQXJyWzBdWzFdXTsKCWZyYW1lX2RpZyAwIC8vIGFyckFycjogdWludDY0W11bXQoJc3RvcmUgMjU1IC8vIGZ1bGwgYXJyYXkKCWxvYWQgMjU1IC8vIGZ1bGwgYXJyYXkKCWludGMgMCAvLyAyCglleHRyYWN0X3VpbnQxNgoJaW50YyAyIC8vICBhY2MgKiB0eXBlTGVuZ3RoCgkrCglpbnRjIDAgLy8gMgoJKyAvLyBhZGQgdHdvIGZvciBsZW5ndGgKCWxvYWQgMjU1IC8vIGZ1bGwgYXJyYXkKCXN3YXAKCWludGMgMSAvLyA4CglleHRyYWN0MwoJYnRvaQoJaXRvYgoJZnJhbWVfZGlnIDAgLy8gYXJyQXJyOiB1aW50NjRbXVtdCglzdG9yZSAyNTUgLy8gZnVsbCBhcnJheQoJbG9hZCAyNTUgLy8gZnVsbCBhcnJheQoJaW50YyAwIC8vIDIKCWV4dHJhY3RfdWludDE2CglpbnRjIDEgLy8gIGFjYyAqIHR5cGVMZW5ndGgKCSsKCWludGMgMCAvLyAyCgkrIC8vIGFkZCB0d28gZm9yIGxlbmd0aAoJbG9hZCAyNTUgLy8gZnVsbCBhcnJheQoJc3dhcAoJaW50YyAxIC8vIDgKCWV4dHJhY3QzCglidG9pCglpdG9iCgljb25jYXQKCgkvLyBzZXQgdGhlIHN1YnJvdXRpbmUgcmV0dXJuIHZhbHVlCglmcmFtZV9idXJ5IDAKCXJldHN1YgoKKmFiaV9yb3V0ZV9jcmVhdGVBcHBsaWNhdGlvbjoKCWludGMgMyAvLyAxCglyZXR1cm4KCipjcmVhdGVfTm9PcDoKCXB1c2hieXRlcyAweGI4NDQ3YjM2IC8vIG1ldGhvZCAiY3JlYXRlQXBwbGljYXRpb24oKXZvaWQiCgl0eG5hIEFwcGxpY2F0aW9uQXJncyAwCgltYXRjaCAqYWJpX3JvdXRlX2NyZWF0ZUFwcGxpY2F0aW9uCgoJLy8gdGhpcyBjb250cmFjdCBkb2VzIG5vdCBpbXBsZW1lbnQgdGhlIGdpdmVuIEFCSSBtZXRob2QgZm9yIGNyZWF0ZSBOb09wCgllcnIKCipjYWxsX05vT3A6CglwdXNoYnl0ZXMgMHhmYTUzMzg2ZiAvLyBtZXRob2QgIm11dGFibGVSZWZJblZhcmlhYmxlRGVjbGFyYXRpb24oKSh1aW50NjQsdWludDY0KSIKCXR4bmEgQXBwbGljYXRpb25BcmdzIDAKCW1hdGNoICphYmlfcm91dGVfbXV0YWJsZVJlZkluVmFyaWFibGVEZWNsYXJhdGlvbgoKCS8vIHRoaXMgY29udHJhY3QgZG9lcyBub3QgaW1wbGVtZW50IHRoZSBnaXZlbiBBQkkgbWV0aG9kIGZvciBjYWxsIE5vT3AKCWVycgoKKnByb2Nlc3NfZHluYW1pY190dXBsZV9lbGVtZW50OgoJcHJvdG8gNCAzCglmcmFtZV9kaWcgLTQgLy8gdHVwbGUgaGVhZAoJZnJhbWVfZGlnIC0yIC8vIGhlYWQgb2Zmc2V0Cgljb25jYXQKCWZyYW1lX2J1cnkgLTQgLy8gdHVwbGUgaGVhZAoJZnJhbWVfZGlnIC0xIC8vIGVsZW1lbnQKCWR1cAoJbGVuCglmcmFtZV9kaWcgLTIgLy8gaGVhZCBvZmZzZXQKCWJ0b2kKCSsKCWl0b2IKCWV4dHJhY3QgNiAyCglmcmFtZV9idXJ5IC0yIC8vIGhlYWQgb2Zmc2V0CglmcmFtZV9kaWcgLTMgLy8gdHVwbGUgdGFpbAoJc3dhcAoJY29uY2F0CglmcmFtZV9idXJ5IC0zIC8vIHR1cGxlIHRhaWwKCWZyYW1lX2RpZyAtNCAvLyB0dXBsZSBoZWFkCglmcmFtZV9kaWcgLTMgLy8gdHVwbGUgdGFpbAoJZnJhbWVfZGlnIC0yIC8vIGhlYWQgb2Zmc2V0CglyZXRzdWI=", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "contract": { + "name": "ABITestMutableRefInVariableDeclaration", + "desc": "", + "methods": [ + { + "name": "mutableRefInVariableDeclaration", + "args": [], + "returns": { + "type": "(uint64,uint64)" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] + } +} \ No newline at end of file diff --git a/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc4.json b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc4.json new file mode 100644 index 000000000..08d2587d8 --- /dev/null +++ b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc4.json @@ -0,0 +1,20 @@ +{ + "name": "ABITestMutableRefInVariableDeclaration", + "desc": "", + "methods": [ + { + "name": "mutableRefInVariableDeclaration", + "args": [], + "returns": { + "type": "(uint64,uint64)" + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + } + } + ] +} \ No newline at end of file diff --git a/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc56.json b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc56.json new file mode 100644 index 000000000..e689a5164 --- /dev/null +++ b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.arc56.json @@ -0,0 +1,1107 @@ +{ + "name": "ABITestMutableRefInVariableDeclaration", + "desc": "", + "methods": [ + { + "name": "mutableRefInVariableDeclaration", + "args": [], + "returns": { + "type": "(uint64,uint64)" + }, + "actions": { + "create": [], + "call": [ + "NoOp" + ] + } + }, + { + "name": "createApplication", + "args": [], + "returns": { + "type": "void" + }, + "actions": { + "create": [ + "NoOp" + ], + "call": [] + } + } + ], + "arcs": [ + 4, + 56 + ], + "structs": {}, + "state": { + "schema": { + "global": { + "bytes": 0, + "ints": 0 + }, + "local": { + "bytes": 0, + "ints": 0 + } + }, + "keys": { + "global": {}, + "local": {}, + "box": {} + }, + "maps": { + "global": {}, + "local": {}, + "box": {} + } + }, + "bareActions": { + "create": [], + "call": [] + }, + "sourceInfo": { + "approval": { + "sourceInfo": [ + { + "teal": 1, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 0 + ] + }, + { + "teal": 2, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 1, + 2, + 3, + 4, + 5, + 6 + ] + }, + { + "teal": 3, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 7, + 8, + 9 + ] + }, + { + "teal": 15, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 10, + 11 + ] + }, + { + "teal": 16, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 12 + ] + }, + { + "teal": 17, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 13, + 14 + ] + }, + { + "teal": 18, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 15 + ] + }, + { + "teal": 19, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 16, + 17 + ] + }, + { + "teal": 20, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 18 + ] + }, + { + "teal": 21, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 30, + 31, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 39, + 40, + 41, + 42, + 43, + 44 + ] + }, + { + "teal": 25, + "source": "tests/contracts/abi.algo.ts:1731", + "errorMessage": "The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?", + "pc": [ + 45 + ] + }, + { + "teal": 30, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 46, + 47, + 48, + 49, + 50, + 51 + ] + }, + { + "teal": 33, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 52, + 53, + 54 + ] + }, + { + "teal": 34, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 55 + ] + }, + { + "teal": 35, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 56 + ] + }, + { + "teal": 36, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 57 + ] + }, + { + "teal": 37, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 58 + ] + }, + { + "teal": 41, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 59, + 60, + 61 + ] + }, + { + "teal": 44, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 62 + ] + }, + { + "teal": 48, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 63 + ] + }, + { + "teal": 49, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 64 + ] + }, + { + "teal": 50, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 65, + 66, + 67, + 68 + ] + }, + { + "teal": 51, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 69, + 70, + 71, + 72, + 73, + 74, + 75, + 76, + 77, + 78, + 79, + 80, + 81, + 82, + 83, + 84, + 85, + 86, + 87, + 88, + 89, + 90, + 91, + 92, + 93, + 94, + 95, + 96 + ] + }, + { + "teal": 52, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 97, + 98, + 99 + ] + }, + { + "teal": 53, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 100 + ] + }, + { + "teal": 54, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 101 + ] + }, + { + "teal": 55, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 102, + 103, + 104, + 105 + ] + }, + { + "teal": 56, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 106 + ] + }, + { + "teal": 57, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 107 + ] + }, + { + "teal": 58, + "source": "tests/contracts/abi.algo.ts:1733", + "pc": [ + 108, + 109 + ] + }, + { + "teal": 64, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 110, + 111 + ] + }, + { + "teal": 65, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 112, + 113 + ] + }, + { + "teal": 66, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 114, + 115 + ] + }, + { + "teal": 67, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 116 + ] + }, + { + "teal": 68, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 117 + ] + }, + { + "teal": 69, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 118 + ] + }, + { + "teal": 70, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 119 + ] + }, + { + "teal": 71, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 120 + ] + }, + { + "teal": 72, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 121 + ] + }, + { + "teal": 73, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 122, + 123 + ] + }, + { + "teal": 74, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 124 + ] + }, + { + "teal": 75, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 125, + 126, + 127, + 128, + 129, + 130, + 131, + 132, + 133, + 134 + ] + }, + { + "teal": 76, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 135 + ] + }, + { + "teal": 77, + "source": "tests/contracts/abi.algo.ts:1737", + "pc": [ + 136, + 137 + ] + }, + { + "teal": 83, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 138, + 139 + ] + }, + { + "teal": 84, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 140, + 141 + ] + }, + { + "teal": 85, + "source": "tests/contracts/abi.algo.ts:1739", + "pc": [ + 142, + 143 + ] + }, + { + "teal": 86, + "source": "tests/contracts/abi.algo.ts:1739", + "pc": [ + 144 + ] + }, + { + "teal": 87, + "source": "tests/contracts/abi.algo.ts:1739", + "pc": [ + 145 + ] + }, + { + "teal": 88, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 146 + ] + }, + { + "teal": 89, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 147 + ] + }, + { + "teal": 90, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 148 + ] + }, + { + "teal": 91, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 149 + ] + }, + { + "teal": 92, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 150, + 151 + ] + }, + { + "teal": 93, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 152 + ] + }, + { + "teal": 94, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 153, + 154, + 155, + 156, + 157, + 158, + 159, + 160, + 161, + 162 + ] + }, + { + "teal": 95, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 163 + ] + }, + { + "teal": 96, + "source": "tests/contracts/abi.algo.ts:1740", + "pc": [ + 164, + 165 + ] + }, + { + "teal": 100, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 166, + 167 + ] + }, + { + "teal": 101, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 168, + 169 + ] + }, + { + "teal": 102, + "source": "tests/contracts/abi.algo.ts:1735", + "pc": [ + 170, + 171 + ] + }, + { + "teal": 103, + "source": "tests/contracts/abi.algo.ts:1735", + "pc": [ + 172 + ] + }, + { + "teal": 104, + "source": "tests/contracts/abi.algo.ts:1735", + "pc": [ + 173 + ] + }, + { + "teal": 105, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 174 + ] + }, + { + "teal": 106, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 175 + ] + }, + { + "teal": 107, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 176 + ] + }, + { + "teal": 108, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 177 + ] + }, + { + "teal": 109, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 178, + 179 + ] + }, + { + "teal": 110, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 180 + ] + }, + { + "teal": 111, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 181 + ] + }, + { + "teal": 112, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 182 + ] + }, + { + "teal": 113, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 183 + ] + }, + { + "teal": 114, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 184 + ] + }, + { + "teal": 115, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 185, + 186 + ] + }, + { + "teal": 116, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 187, + 188 + ] + }, + { + "teal": 117, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 189, + 190 + ] + }, + { + "teal": 118, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 191 + ] + }, + { + "teal": 119, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 192 + ] + }, + { + "teal": 120, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 193 + ] + }, + { + "teal": 121, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 194 + ] + }, + { + "teal": 122, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 195 + ] + }, + { + "teal": 123, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 196 + ] + }, + { + "teal": 124, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 197, + 198 + ] + }, + { + "teal": 125, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 199 + ] + }, + { + "teal": 126, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 200 + ] + }, + { + "teal": 127, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 201 + ] + }, + { + "teal": 128, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 202 + ] + }, + { + "teal": 129, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 203 + ] + }, + { + "teal": 130, + "source": "tests/contracts/abi.algo.ts:1742", + "pc": [ + 204 + ] + }, + { + "teal": 133, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 205, + 206 + ] + }, + { + "teal": 134, + "source": "tests/contracts/abi.algo.ts:1732", + "pc": [ + 207 + ] + }, + { + "teal": 137, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 208 + ] + }, + { + "teal": 138, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 209 + ] + }, + { + "teal": 141, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 210, + 211, + 212, + 213, + 214, + 215 + ] + }, + { + "teal": 142, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 216, + 217, + 218 + ] + }, + { + "teal": 143, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 219, + 220, + 221, + 222 + ] + }, + { + "teal": 146, + "source": "tests/contracts/abi.algo.ts:1731", + "errorMessage": "this contract does not implement the given ABI method for create NoOp", + "pc": [ + 223 + ] + }, + { + "teal": 149, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 224, + 225, + 226, + 227, + 228, + 229 + ] + }, + { + "teal": 150, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 230, + 231, + 232 + ] + }, + { + "teal": 151, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 233, + 234, + 235, + 236 + ] + }, + { + "teal": 154, + "source": "tests/contracts/abi.algo.ts:1731", + "errorMessage": "this contract does not implement the given ABI method for call NoOp", + "pc": [ + 237 + ] + }, + { + "teal": 157, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 238, + 239, + 240 + ] + }, + { + "teal": 158, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 241, + 242 + ] + }, + { + "teal": 159, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 243, + 244 + ] + }, + { + "teal": 160, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 245 + ] + }, + { + "teal": 161, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 246, + 247 + ] + }, + { + "teal": 162, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 248, + 249 + ] + }, + { + "teal": 163, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 250 + ] + }, + { + "teal": 164, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 251 + ] + }, + { + "teal": 165, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 252, + 253 + ] + }, + { + "teal": 166, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 254 + ] + }, + { + "teal": 167, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 255 + ] + }, + { + "teal": 168, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 256 + ] + }, + { + "teal": 169, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 257, + 258, + 259 + ] + }, + { + "teal": 170, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 260, + 261 + ] + }, + { + "teal": 171, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 262, + 263 + ] + }, + { + "teal": 172, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 264 + ] + }, + { + "teal": 173, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 265 + ] + }, + { + "teal": 174, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 266, + 267 + ] + }, + { + "teal": 175, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 268, + 269 + ] + }, + { + "teal": 176, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 270, + 271 + ] + }, + { + "teal": 177, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 272, + 273 + ] + }, + { + "teal": 178, + "source": "tests/contracts/abi.algo.ts:1731", + "pc": [ + 274 + ] + } + ], + "pcOffsetMethod": "none" + }, + "clear": { + "sourceInfo": [], + "pcOffsetMethod": "none" + } + }, + "source": { + "approval": "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", + "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" + }, + "byteCode": { + "approval": "CiAEAggAASYBADEYFIEGCzEZCI0MALMAAAAAAAAAAAAAAKUAAAAAAAAAAAAAAIAEFR98dYgABFCwJUOKAAEoKCiAAgACgBoAAwAAAAAAAAABAAAAAAAAAAIAAAAAAAAAA4gAikhQgAIAAUxQjACLADX/NP8iWSQIIgg0/0yACAAAAAAAAAAHXYwAiwA1/zT/IlkjCCIINP9MgAgAAAAAAAAACF2MAIsANf80/yJZJAgiCDT/TCNYFxaLADX/NP8iWSMIIgg0/0wjWBcWUIwAiSVDgAS4RHs2NhoAjgH/8QCABPpTOG82GgCOAf9BAIoEA4v8i/5QjPyL/0kVi/4XCBZXBgKM/ov9TFCM/Yv8i/2L/ok=", + "clear": "Cg==" + }, + "compilerInfo": { + "compiler": "algod", + "compilerVersion": { + "major": 4, + "minor": 0, + "patch": 2, + "commitHash": "6b940281" + } + } +} \ No newline at end of file diff --git a/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.clear.teal b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.clear.teal new file mode 100644 index 000000000..e9f1d65b3 --- /dev/null +++ b/tests/contracts/artifacts/ABITestMutableRefInVariableDeclaration.clear.teal @@ -0,0 +1 @@ +#pragma version 10 \ No newline at end of file diff --git a/tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts b/tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts deleted file mode 100644 index c5a13b010..000000000 --- a/tests/contracts/reference_errors/MutableRefInVariableDeclaration.algo.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -export class MutableRefInVariableDeclaration extends Contract { - mutableRefInVariableDeclaration() { - const arrArr: uint64[][] = [[1, 2, 3]]; - - const x = arrArr[0]; - - arrArr[0][0] = 7; // <-- Error here because the canonical reference to arrArr[0] is now x - - assert(x[0] === 7); - } -} diff --git a/tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts b/tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts deleted file mode 100644 index 33dc38c9f..000000000 --- a/tests/contracts/reference_errors/MutableRefInVariableDeclarationWithDynamicIndex.algo.ts +++ /dev/null @@ -1,14 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -export class MutableRefInVariableDeclarationWithDynamicIndex extends Contract { - mutableRefInVariableDeclaration() { - const arrArr: uint64[][] = [[1, 2, 3]]; - - const i = 0; - const x = arrArr[i]; - - arrArr[0][0] = 7; // <-- Error here because the canonical reference to arrArr is now x (because of dynamic index) - - assert(x[0] === 7); - } -} diff --git a/tests/references.test.ts b/tests/references.test.ts index 03bcd7973..a4ee895e1 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -50,16 +50,4 @@ describe('Reference Compile Errors', () => { ); compilerErrorTest('MutableRefInPush', 'Cannot access or create a reference to an mutable type', 'arr[0] = 4'); - - compilerErrorTest( - 'MutableRefInVariableDeclaration', - 'Cannot access or create a reference to an mutable type', - 'arrArr[0][0] = 7' - ); - - compilerErrorTest( - 'MutableRefInVariableDeclarationWithDynamicIndex', - 'Cannot access or create a reference to an mutable type', - 'arrArr[0][0] = 7' - ); }); From b05c37daca0a72b5f1f061cb8ca137b2da0b2091 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 10:54:08 -0400 Subject: [PATCH 13/29] wip: ref checker 2 --- src/lib/compiler.ts | 2 +- src/lib/ref_checker2.ts | 113 ++++++++++++++++++ .../ArrayWithAliasMutation.algo.ts | 18 +++ .../ArrayWithNestedRefMutation.algo.ts | 14 +++ .../ArrayWithRefMutation.algo.ts | 18 +++ .../MutableRefInArrayAssignment.algo.ts | 12 -- .../MutableRefInArrayLiteral.algo.ts | 13 -- .../MutableRefInObjAssignment.algo.ts | 20 ---- .../MutableRefInObjLiteral.algo.ts | 18 --- .../reference_errors/MutableRefInPush.algo.ts | 13 -- tests/references.test.ts | 33 ++--- 11 files changed, 171 insertions(+), 103 deletions(-) create mode 100644 src/lib/ref_checker2.ts create mode 100644 tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts create mode 100644 tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts create mode 100644 tests/contracts/reference_errors/ArrayWithRefMutation.algo.ts delete mode 100644 tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts delete mode 100644 tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts delete mode 100644 tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts delete mode 100644 tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts delete mode 100644 tests/contracts/reference_errors/MutableRefInPush.algo.ts diff --git a/src/lib/compiler.ts b/src/lib/compiler.ts index d223ba97b..95e631de8 100644 --- a/src/lib/compiler.ts +++ b/src/lib/compiler.ts @@ -14,7 +14,7 @@ import langspec from '../static/langspec.json'; import { VERSION } from '../version'; import { optimizeTeal } from './optimize'; import { type ARC56Contract, type StructField } from '../types/arc56.d'; -import { checkRefs } from './ref_checker'; +import { checkRefs } from './ref_checker2'; import { getExpressionChain, ExpressionChainNode } from './utils'; const MULTI_OUTPUT_TYPES = ['split uint128', 'divmodw output', 'vrf return values', 'ecdsa pubkey']; diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts new file mode 100644 index 000000000..9983558be --- /dev/null +++ b/src/lib/ref_checker2.ts @@ -0,0 +1,113 @@ +/* eslint-disable no-console */ + +import * as ts from 'ts-morph'; +import { getExpressionChain } from './utils'; + +function includesNode(haystack: ts.Node, needle: ts.Node): boolean { + if (haystack.getText() === needle.getText()) return true; + if (haystack.isKind(ts.SyntaxKind.ArrayLiteralExpression)) { + return haystack.getElements().some((e) => { + return includesNode(e, needle); + }); + } + + if ( + !haystack.isKind(ts.SyntaxKind.PropertyAccessExpression) && + !haystack.isKind(ts.SyntaxKind.ElementAccessExpression) + ) + return false; + + const chain = getExpressionChain(haystack); + + return [chain.base, ...chain.chain].some((e) => { + return e.getText() === needle.getText(); + }); +} + +function getNodeLines(node: ts.Node, pathStr: string) { + const refFullLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1].trim(); + + return `${pathStr}:${node.getStartLineNumber()}:${ + ts.ts.getLineAndCharacterOfPosition(node.getSourceFile().compilerNode, node.getPos()).character + }\n ${refFullLine}`; +} + +function getAliases(node: ts.Node, methodBody: ts.Node) { + const aliases: ts.Node[] = [node]; + methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((variable) => { + const init = variable.getInitializer(); + if (init && node.getText() === init.getText()) { + aliases.push(variable.getNameNode()); + } + }); + return aliases; +} + +function referencesInArrayLiterals(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((variable) => { + if (variable.getInitializer()?.isKind(ts.SyntaxKind.ArrayLiteralExpression)) { + const array = variable.getInitializer() as ts.ArrayLiteralExpression; + array.getElements().forEach((element) => { + if (includesNode(element, node)) { + nodes.push(variable.getNameNode()); + } + }); + } + }); + return nodes; +} + +function mutationByAssignment(node: ts.Node, methodBody: ts.Node) { + const mutations: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression).forEach((n) => { + if (n.getOperatorToken().getText() !== '=') return; + if (includesNode(n.getLeft(), node)) { + mutations.push(n); + } + }); + + return mutations; +} + +function isAlias(a: ts.Node, b: ts.Node, methodBody: ts.Node) { + return getAliases(a, methodBody).includes(b) || getAliases(b, methodBody).includes(a); +} + +export function checkRefs(file: ts.SourceFile, pathStr: string) { + file.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration).forEach((method) => { + const methodBody = method.getBody(); + if (!methodBody) return; + const variables = methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration); + variables.forEach((variable) => { + const aliases = getAliases(variable.getNameNode(), methodBody); + const refs: ts.Node[] = []; + + aliases.forEach((alias) => { + refs.push(...referencesInArrayLiterals(alias, methodBody)); + }); + + const mutations: ts.Node[] = []; + + [...aliases, ...refs].forEach((ref) => { + const refMutations = mutationByAssignment(ref, methodBody); + + refMutations.forEach((m) => { + // All non-alias references that came before the mutation are now stale + const staleRefs = [...aliases, ...refs].filter( + (r) => r !== ref && r.getPos() < m.getPos() && !isAlias(r, ref, methodBody) + ); + + staleRefs.forEach((r) => { + methodBody.getDescendantsOfKind(r.getKind()).forEach((d) => { + if (d.getPos() >= m.getPos() && d.getText() === r.getText()) throw Error(getNodeLines(d, pathStr)); + }); + }); + }); + mutations.push(...refMutations); + }); + }); + }); +} diff --git a/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts new file mode 100644 index 000000000..9a9ee161c --- /dev/null +++ b/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts @@ -0,0 +1,18 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayWithAliasMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const alias = val; + const arrWithVal: uint64[][] = [val]; + const arrWithAlias: uint64[][] = [alias]; + const objWithVal: { arr: uint64[] } = { arr: val }; + const objWithAlias: { arr: uint64[] } = { arr: alias }; + + assert(arrWithVal[0][1] === 2); // Works because nothing has been made stale yet (no mutations) + + alias[0] = 5; // Invalidate other references + + assert(arrWithVal[0][2] === 3); // Error because now arrWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts new file mode 100644 index 000000000..4cbc41be8 --- /dev/null +++ b/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts @@ -0,0 +1,14 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayWithNestedRefMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const arrWithVal: uint64[][][] = [[val]]; + + assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + + arrWithVal[0][0][0] = 4; // Invalidate other references + + assert(val[2] === 3); // Error because now arrWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ArrayWithRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithRefMutation.algo.ts new file mode 100644 index 000000000..b4e6808e8 --- /dev/null +++ b/tests/contracts/reference_errors/ArrayWithRefMutation.algo.ts @@ -0,0 +1,18 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayWithRefMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const alias = val; + const arrWithVal: uint64[][] = [val]; + const arrWithAlias: uint64[][] = [alias]; + const objWithVal: { arr: uint64[] } = { arr: val }; + const objWithAlias: { arr: uint64[] } = { arr: alias }; + + assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + + arrWithVal[0][0] = 5; // Invalidate other references + + assert(val[2] === 3); // Error because now arrWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts b/tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts deleted file mode 100644 index 35ff45167..000000000 --- a/tests/contracts/reference_errors/MutableRefInArrayAssignment.algo.ts +++ /dev/null @@ -1,12 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -export class MutableRefInArrayAssignment extends Contract { - mutableRefInArray() { - const arr: uint64[] = [1, 2, 3]; - const arrArr: uint64[][] = [arr]; - - arrArr[0] = arr; - - assert(arr[0] === arrArr[0][0]); - } -} diff --git a/tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts b/tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts deleted file mode 100644 index d28d4646c..000000000 --- a/tests/contracts/reference_errors/MutableRefInArrayLiteral.algo.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -export class MutableRefInArrayLiteral extends Contract { - mutableRefInArray() { - const arr: uint64[] = [1, 2, 3]; - const arrArr: uint64[][] = [arr]; - - arr[0] = 4; - arrArr[0][0] = 5; - - assert(arr[0] === arrArr[0][0]); - } -} diff --git a/tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts b/tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts deleted file mode 100644 index 42b48c9eb..000000000 --- a/tests/contracts/reference_errors/MutableRefInObjAssignment.algo.ts +++ /dev/null @@ -1,20 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -type ArrObj = { - arr: uint64[]; -}; - -export class MutableRefInObjAssignment extends Contract { - mutableRefInObj() { - const arr: uint64[] = [1, 2, 3]; - - const arrObj: ArrObj = { arr: [] as uint64[] }; - - arrObj.arr = arr; - - arr[0] = 4; - arrObj.arr[0] = 5; - - assert(arr[0] === arrObj.arr[0]); - } -} diff --git a/tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts b/tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts deleted file mode 100644 index 81b378b1c..000000000 --- a/tests/contracts/reference_errors/MutableRefInObjLiteral.algo.ts +++ /dev/null @@ -1,18 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -type ArrObj = { - arr: uint64[]; -}; - -export class MutableRefInObjLiteral extends Contract { - mutableRefInObj() { - const arr: uint64[] = [1, 2, 3]; - - const arrObj: ArrObj = { arr: arr }; - - arr[0] = 4; - arrObj.arr[0] = 5; - - assert(arr[0] === arrObj.arr[0]); - } -} diff --git a/tests/contracts/reference_errors/MutableRefInPush.algo.ts b/tests/contracts/reference_errors/MutableRefInPush.algo.ts deleted file mode 100644 index 3f78c0f3d..000000000 --- a/tests/contracts/reference_errors/MutableRefInPush.algo.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { Contract } from '../../../src/lib/index'; - -export class MutableRefInPush extends Contract { - mutableRefInPush() { - const arr: uint64[] = [1, 2, 3]; - const arrArr: uint64[][] = []; - arrArr.push(arr); - arr[0] = 4; - arrArr[0][0] = 5; - - assert(arr[0] === arrArr[0][0]); - } -} diff --git a/tests/references.test.ts b/tests/references.test.ts index a4ee895e1..6d87e8bd3 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -4,7 +4,7 @@ import { compileAndCreate } from './common'; const ARTIFACTS_DIR = 'tests/contracts/artifacts'; -function compilerErrorTest(contractName: string, errorMsg: string, line: string) { +function compilerErrorTest(contractName: string, errorMsg: string) { test(contractName, async () => { let msg: string; try { @@ -17,37 +17,18 @@ function compilerErrorTest(contractName: string, errorMsg: string, line: string) msg = 'No error'; // eslint-disable-next-line @typescript-eslint/no-explicit-any } catch (e: any) { - if (!(e.message as string).match(errorMsg)) { - throw e; - } + // if (!(e.message as string).match(errorMsg)) { + // throw e; + // } msg = e.message; } expect(msg).toMatch(errorMsg); - expect(msg).toMatch(line); }); } describe('Reference Compile Errors', () => { - compilerErrorTest( - 'MutableRefInObjLiteral', - 'Cannot access or create a reference to an mutable type', - 'const arrObj: ArrObj = { arr: arr }' - ); - - compilerErrorTest( - 'MutableRefInObjAssignment', - 'Cannot access or create a reference to an mutable type', - 'arrObj.arr = arr' - ); - - compilerErrorTest('MutableRefInArrayLiteral', 'Cannot access or create a reference to an mutable type', 'arr[0] = 4'); - - compilerErrorTest( - 'MutableRefInArrayAssignment', - 'Cannot access or create a reference to an mutable type', - 'arrArr[0] = arr' - ); - - compilerErrorTest('MutableRefInPush', 'Cannot access or create a reference to an mutable type', 'arr[0] = 4'); + compilerErrorTest('ArrayWithAliasMutation', 'assert(arrWithVal[0][2] === 3)'); + compilerErrorTest('ArrayWithRefMutation', 'assert(val[2] === 3)'); + compilerErrorTest('ArrayWithNestedRefMutation', 'assert(val[2] === 3)'); }); From 06b21171dbda0038250e49f4b3c57a3774526a87 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 11:19:10 -0400 Subject: [PATCH 14/29] wip: array in obj tests --- src/lib/ref_checker2.ts | 24 ++++++++++++++++++- .../ArrayInObjWithAliasMutation.algo.ts | 15 ++++++++++++ .../ArrayInObjWithNestedRefMutation.algo.ts | 14 +++++++++++ .../ArrayInObjWithRefMutation.algo.ts | 14 +++++++++++ tests/references.test.ts | 3 +++ 5 files changed, 69 insertions(+), 1 deletion(-) create mode 100644 tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts create mode 100644 tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts create mode 100644 tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 9983558be..556279366 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -43,6 +43,26 @@ function getAliases(node: ts.Node, methodBody: ts.Node) { return aliases; } +function referencesInObjectLiterals(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).forEach((variable) => { + if (variable.getInitializer()?.isKind(ts.SyntaxKind.ObjectLiteralExpression)) { + const obj = variable.getInitializer() as ts.ObjectLiteralExpression; + obj.getProperties().forEach((p) => { + // TODO: Support short-hand + if (!p.isKind(ts.SyntaxKind.PropertyAssignment)) throw new Error(); + const val = p.getInitializer(); + if (val && includesNode(val, node)) { + nodes.push(variable.getNameNode()); + } + }); + } + }); + + return nodes; +} + function referencesInArrayLiterals(node: ts.Node, methodBody: ts.Node) { const nodes: ts.Node[] = []; @@ -86,7 +106,9 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { const refs: ts.Node[] = []; aliases.forEach((alias) => { - refs.push(...referencesInArrayLiterals(alias, methodBody)); + refs.push( + ...[...referencesInArrayLiterals(alias, methodBody), ...referencesInObjectLiterals(alias, methodBody)] + ); }); const mutations: ts.Node[] = []; diff --git a/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts new file mode 100644 index 000000000..4bab42f98 --- /dev/null +++ b/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts @@ -0,0 +1,15 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayInObjWithAliasMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const alias = val; + const objWithVal: { arr: uint64[] } = { arr: val }; + + assert(objWithVal.arr[1] === 2); // Works because nothing has been made stale yet (no mutations) + + alias[0] = 5; // Invalidate other references + + assert(objWithVal.arr[2] === 3); // Error because now objWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts new file mode 100644 index 000000000..f6da82466 --- /dev/null +++ b/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts @@ -0,0 +1,14 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayInObjWithNestedRefMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const objWithVal: { foo: uint64[][] } = { foo: [val] }; + + assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + + objWithVal.foo[0][0] = 4; // Invalidate other references + + assert(val[2] === 3); // Error because now arrWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts new file mode 100644 index 000000000..5adcacc06 --- /dev/null +++ b/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts @@ -0,0 +1,14 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayInObjWithRefMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const objWithVal: { arr: uint64[] } = { arr: val }; + + assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + + objWithVal.arr[0] = 5; // Invalidate other references + + assert(val[2] === 3); // Error because now val is stale + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 6d87e8bd3..936c01064 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -31,4 +31,7 @@ describe('Reference Compile Errors', () => { compilerErrorTest('ArrayWithAliasMutation', 'assert(arrWithVal[0][2] === 3)'); compilerErrorTest('ArrayWithRefMutation', 'assert(val[2] === 3)'); compilerErrorTest('ArrayWithNestedRefMutation', 'assert(val[2] === 3)'); + compilerErrorTest('ArrayInObjWithAliasMutation', 'assert(objWithVal.arr[2] === 3)'); + compilerErrorTest('ArrayInObjWithRefMutation', 'assert(val[2] === 3)'); + compilerErrorTest('ArrayInObjWithNestedRefMutation', 'assert(val[2] === 3)'); }); From 185d26b4d99008ddb9df9c952b7fe69a2466a101 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 11:34:29 -0400 Subject: [PATCH 15/29] wip: obj tests --- src/lib/ref_checker2.ts | 11 ++++++++++- .../reference_errors/ObjWithAliasMutation.algo.ts | 15 +++++++++++++++ .../ObjWithNestedRefMutation.algo.ts | 14 ++++++++++++++ .../reference_errors/ObjWithRefMutation.algo.ts | 14 ++++++++++++++ tests/references.test.ts | 3 +++ 5 files changed, 56 insertions(+), 1 deletion(-) create mode 100644 tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts create mode 100644 tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts create mode 100644 tests/contracts/reference_errors/ObjWithRefMutation.algo.ts diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 556279366..010bfc720 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -11,6 +11,15 @@ function includesNode(haystack: ts.Node, needle: ts.Node): boolean { }); } + if (haystack.isKind(ts.SyntaxKind.ObjectLiteralExpression)) { + return haystack.getProperties().some((p) => { + // TODO:(puya) Support short-hand + if (!p.isKind(ts.SyntaxKind.PropertyAssignment)) throw new Error(); + const val = p.getInitializer(); + return val && includesNode(val, needle); + }); + } + if ( !haystack.isKind(ts.SyntaxKind.PropertyAccessExpression) && !haystack.isKind(ts.SyntaxKind.ElementAccessExpression) @@ -50,7 +59,7 @@ function referencesInObjectLiterals(node: ts.Node, methodBody: ts.Node) { if (variable.getInitializer()?.isKind(ts.SyntaxKind.ObjectLiteralExpression)) { const obj = variable.getInitializer() as ts.ObjectLiteralExpression; obj.getProperties().forEach((p) => { - // TODO: Support short-hand + // TODO:(puya) Support short-hand if (!p.isKind(ts.SyntaxKind.PropertyAssignment)) throw new Error(); const val = p.getInitializer(); if (val && includesNode(val, node)) { diff --git a/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts new file mode 100644 index 000000000..ab544e5d4 --- /dev/null +++ b/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts @@ -0,0 +1,15 @@ +import { Contract } from '../../../src/lib/index'; + +export class ObjWithAliasMutation extends Contract { + test(): void { + const val: { foo: uint64 } = { foo: 1337 }; + const alias = val; + const objWithVal: { bar: { foo: uint64 } } = { bar: val }; + + assert(objWithVal.bar.foo === 1337); // Works because nothing has been made stale yet (no mutations) + + alias.foo = 7331; // Invalidate other references + + assert(objWithVal.bar.foo === 7331); // Error because now objWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts b/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts new file mode 100644 index 000000000..ea895464b --- /dev/null +++ b/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts @@ -0,0 +1,14 @@ +import { Contract } from '../../../src/lib/index'; + +export class ObjWithNestedRefMutation extends Contract { + test(): void { + const val: { foo: uint64 } = { foo: 1337 }; + const objWithVal: { baz: { bar: { foo: uint64 } } } = { baz: { bar: val } }; + + assert(val.foo === 1337); // Works because nothing has been made stale yet (no mutations) + + objWithVal.baz.bar.foo = 7331; // Invalidate other references + + assert(val.foo === 7331); // Error because now objWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts b/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts new file mode 100644 index 000000000..427ba1ad5 --- /dev/null +++ b/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts @@ -0,0 +1,14 @@ +import { Contract } from '../../../src/lib/index'; + +export class ObjWithRefMutation extends Contract { + test(): void { + const val: { foo: uint64 } = { foo: 1337 }; + const objWithVal: { bar: { foo: uint64 } } = { bar: val }; + + assert(val.foo === 1337); // Works because nothing has been made stale yet (no mutations) + + objWithVal.bar.foo = 7331; // Invalidate other references + + assert(val.foo === 7331); // Error because now objWithVal is stale + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 936c01064..17a493087 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -34,4 +34,7 @@ describe('Reference Compile Errors', () => { compilerErrorTest('ArrayInObjWithAliasMutation', 'assert(objWithVal.arr[2] === 3)'); compilerErrorTest('ArrayInObjWithRefMutation', 'assert(val[2] === 3)'); compilerErrorTest('ArrayInObjWithNestedRefMutation', 'assert(val[2] === 3)'); + compilerErrorTest('ObjWithAliasMutation', 'assert(objWithVal.bar.foo === 7331)'); + compilerErrorTest('ObjWithRefMutation', 'assert(val.foo === 7331)'); + compilerErrorTest('ObjWithNestedRefMutation', 'assert(val.foo === 7331)'); }); From 32a8d771b7c39410365cf98d00d786a5d756f645 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 14:00:52 -0400 Subject: [PATCH 16/29] wip: compile all --- .../artifacts/ValidatorRegistry.approval.teal | 4 +- .../artifacts/ValidatorRegistry.arc32.json | 2 +- .../artifacts/ValidatorRegistry.arc56.json | 2 +- examples/tuple_in_box/app.algo.ts | 2 +- src/lib/ref_checker2.ts | 69 ++++++++++++++++++- .../ArrayWithFnMutation.algo.ts | 17 +++++ tests/references.test.ts | 1 + 7 files changed, 91 insertions(+), 6 deletions(-) create mode 100644 tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts diff --git a/examples/reti/artifacts/ValidatorRegistry.approval.teal b/examples/reti/artifacts/ValidatorRegistry.approval.teal index 3574f1e6d..acd5db7a7 100644 --- a/examples/reti/artifacts/ValidatorRegistry.approval.teal +++ b/examples/reti/artifacts/ValidatorRegistry.approval.teal @@ -2376,7 +2376,7 @@ addStake: *if10_end: // examples/reti/validatorRegistry.algo.ts:696 - // this.updateStakerPoolSet(staker, poolKey) + // this.updateStakerPoolSet(staker, clone(poolKey)) frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool) store 255 // full array load 255 // full array @@ -2387,7 +2387,7 @@ addStake: // examples/reti/validatorRegistry.algo.ts:699 // this.callPoolAddStake( // stakedAmountPayment, - // poolKey, + // clone(poolKey), // mbrAmtLeftBehind, // isNewStakerToValidator, // isNewStakerToProtocol diff --git a/examples/reti/artifacts/ValidatorRegistry.arc32.json b/examples/reti/artifacts/ValidatorRegistry.arc32.json index 72c56f3f4..115754c33 100644 --- a/examples/reti/artifacts/ValidatorRegistry.arc32.json +++ b/examples/reti/artifacts/ValidatorRegistry.arc32.json @@ -221,7 +221,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, poolKey)
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       poolKey,
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, clone(poolKey))
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       clone(poolKey),
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "contract": { diff --git a/examples/reti/artifacts/ValidatorRegistry.arc56.json b/examples/reti/artifacts/ValidatorRegistry.arc56.json index d8c8f2220..635c7ee39 100644 --- a/examples/reti/artifacts/ValidatorRegistry.arc56.json +++ b/examples/reti/artifacts/ValidatorRegistry.arc56.json @@ -28561,7 +28561,7 @@ } }, "source": { - "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, poolKey)
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       poolKey,
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", + "approval": "#pragma version 10
intcblock 0 1 8 24 32 18 268 6 242 3 2 10 252 260 700 100000 900 40 200 TMPL_nfdRegistryAppId 4 72 192 244 1000000 4096 5 226 300 432 892 1000 28500 50000 11 80 145 153 209
bytecblock 0x76 0x 0x151f7c75 0x737073 0x7374616b6564 0x00 0x706f6f6c54656d706c617465417070726f76616c4279746573 0x6e756d5374616b657273 0x0a8101 0x692e6f776e65722e61 0x0000000000000000 0x696e6974 0x6e756d56 0x69735f76616c69645f6e66645f6170706964 0x63f3f28b

// This TEAL was generated by TEALScript v0.106.3
// https://github.com/algorandfoundation/TEALScript

// This contract is compliant with and/or implements the following ARCs: [ ARC4 ]

// The following ten lines of TEAL handle initial program flow
// This pattern is used to make it easy for anyone to parse the start of the program and determine if a specific action is allowed
// Here, action refers to the OnComplete in combination with whether the app is being created or called
// Every possible action for this contract is represented in the switch statement
// If the action is not implemented in the contract, its respective branch will be "*NOT_IMPLEMENTED" which just contains "err"
txn ApplicationID
!
intc 7 // 6
*
txn OnCompletion
+
switch *call_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *call_UpdateApplication *NOT_IMPLEMENTED *create_NoOp *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED *NOT_IMPLEMENTED

*NOT_IMPLEMENTED:
	// The requested action is not implemented in this contract. Are you using the correct OnComplete? Did you set your app ID?
	err

// updateApplication()void
*abi_route_updateApplication:
	// execute updateApplication()void
	callsub updateApplication
	intc 1 // 1
	return

// updateApplication(): void
updateApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:202
	// assert(this.txn.sender === Address.fromAddress('LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ'))
	txn Sender
	pushbytes 0x5e795d223558ae54ab91226bc980c451313068cc8fa62d6f9c7076bd80bb65af // addr "LZ4V2IRVLCXFJK4REJV4TAGEKEYTA2GMR6TC2344OB3L3AF3MWXZ6ZAFIQ"
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:204
	// this.stakingPoolApprovalProgram.delete()
	bytec 6 //  "poolTemplateApprovalBytes"
	box_del

	// examples/reti/validatorRegistry.algo.ts:205
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// createApplication()void
*abi_route_createApplication:
	// execute createApplication()void
	callsub createApplication
	intc 1 // 1
	return

// createApplication(): void
createApplication:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:209
	// this.stakingPoolInitialized.value = false
	bytec 11 //  "init"
	intc 0 // 0
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:210
	// this.numValidators.value = 0
	bytec 12 //  "numV"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:211
	// this.numStakers.value = 0
	bytec 7 //  "numStakers"
	intc 0 // 0
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:212
	// this.totalAlgoStaked.value = 0
	bytec 4 //  "staked"
	intc 0 // 0
	app_global_put
	retsub

// initStakingContract(uint64)void
*abi_route_initStakingContract:
	// approvalProgramSize: uint64
	txna ApplicationArgs 1
	btoi

	// execute initStakingContract(uint64)void
	callsub initStakingContract
	intc 1 // 1
	return

// initStakingContract(approvalProgramSize: uint64): void
initStakingContract:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:217
	// this.stakingPoolApprovalProgram.create(approvalProgramSize)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // approvalProgramSize: uint64
	box_create
	pop
	retsub

// loadStakingContractData(uint64,byte[])void
*abi_route_loadStakingContractData:
	// data: byte[]
	txna ApplicationArgs 2
	extract 2 0

	// offset: uint64
	txna ApplicationArgs 1
	btoi

	// execute loadStakingContractData(uint64,byte[])void
	callsub loadStakingContractData
	intc 1 // 1
	return

// loadStakingContractData(offset: uint64, data: bytes): void
loadStakingContractData:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:221
	// assert(!this.stakingPoolInitialized.value)
	bytec 11 //  "init"
	app_global_get
	intc 0 // 0
	getbit
	!
	assert

	// examples/reti/validatorRegistry.algo.ts:222
	// this.stakingPoolApprovalProgram.replace(offset, data)
	bytec 6 //  "poolTemplateApprovalBytes"
	frame_dig -1 // offset: uint64
	frame_dig -2 // data: bytes
	box_replace
	retsub

// finalizeStakingContract()void
*abi_route_finalizeStakingContract:
	// execute finalizeStakingContract()void
	callsub finalizeStakingContract
	intc 1 // 1
	return

// finalizeStakingContract(): void
finalizeStakingContract:
	proto 0 0

	// examples/reti/validatorRegistry.algo.ts:226
	// this.stakingPoolInitialized.value = true
	bytec 11 //  "init"
	intc 1 // 1
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	app_global_put
	retsub

// gas()void
*abi_route_gas:
	// execute gas()void
	callsub gas
	intc 1 // 1
	return

// gas(): void
//
// gas is a dummy no-op call that can be used to pool-up resource references and opcode cost
gas:
	proto 0 0
	retsub

// getMbrAmounts()(uint64,uint64,uint64,uint64)
*abi_route_getMbrAmounts:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getMbrAmounts()(uint64,uint64,uint64,uint64)
	callsub getMbrAmounts
	concat
	log
	intc 1 // 1
	return

// getMbrAmounts(): MbrAmounts
//
// Returns the MBR amounts needed for various actions:
// [
// addValidatorMbr: uint64 - mbr needed to add a new validator - paid to validator contract
// addPoolMbr: uint64 - mbr needed to add a new pool - paid to validator
// poolInitMbr: uint64 - mbr needed to initStorage() of pool - paid to pool itself
// addStakerMbr: uint64 - mbr staker needs to add to first staking payment (stays w/ validator)
// ]
getMbrAmounts:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:246
	// return {
	//       addValidatorMbr: this.costForBoxStorage(1 /* v prefix */ + len<ValidatorIdType>() + len<ValidatorInfo>()),
	//       addPoolMbr: this.minBalanceForAccount(
	//         1,
	//         // we could calculate this directly by referencing the size of stakingPoolApprovalProgram but it would
	//         // mean our callers would have to reference the box AND buy up i/o - so just go max on extra pages
	//         3,
	//         0,
	//         0,
	//         0,
	//         StakingPool.schema.global.numUint,
	//         StakingPool.schema.global.numByteSlice
	//       ),
	//       poolInitMbr:
	//         ALGORAND_ACCOUNT_MIN_BALANCE +
	//         this.costForBoxStorage(7 /* 'stakers' name */ + len<StakedInfo>() * MAX_STAKERS_PER_POOL),
	//       addStakerMbr:
	//         // how much to charge for first time a staker adds stake - since we add a tracking box per staker
	//         this.costForBoxStorage(3 /* 'sps' prefix */ + len<Address>() + len<ValidatorPoolKey>() * MAX_POOLS_PER_STAKER), // size of key + all values
	//     };
	pushint 1101
	callsub costForBoxStorage
	itob
	intc 9 // 3
	intc 34 // 11
	intc 0 // 0
	dupn 2
	intc 9 // 3
	intc 1 // 1
	callsub minBalanceForAccount
	itob
	concat
	intc 15 // 100000
	pushint 12807
	callsub costForBoxStorage
	+
	itob
	concat
	pushint 179
	callsub costForBoxStorage
	itob
	concat
	retsub

// getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
*abi_route_getProtocolConstraints:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)
	callsub getProtocolConstraints
	concat
	log
	intc 1 // 1
	return

// getProtocolConstraints(): Constraints
//
// Returns the protocol constraints so that UIs can limit what users specify for validator configuration parameters.
getProtocolConstraints:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:272
	// return {
	//       epochPayoutRoundsMin: MIN_EPOCH_LENGTH,
	//       epochPayoutRoundsMax: MAX_EPOCH_LENGTH,
	//       minPctToValidatorWFourDecimals: MIN_PCT_TO_VALIDATOR,
	//       maxPctToValidatorWFourDecimals: MAX_PCT_TO_VALIDATOR,
	//       minEntryStake: MIN_ALGO_STAKE_PER_POOL,
	//       maxAlgoPerPool: this.maxAlgoAllowedPerPool(),
	//       maxAlgoPerValidator: this.maxAllowedStake(),
	//       amtConsideredSaturated: this.algoSaturationLevel(),
	//       maxNodes: MAX_NODES,
	//       maxPoolsPerNode: MAX_POOLS_PER_NODE,
	//       maxStakersPerPool: MAX_STAKERS_PER_POOL,
	//     };
	pushbytes 0x000000000000000100000000000f4240000000000000000000000000000f424000000000000f4240
	callsub maxAlgoAllowedPerPool
	itob
	concat
	callsub maxAllowedStake
	itob
	concat
	callsub algoSaturationLevel
	itob
	concat
	pushbytes 0x0000000000000008
	concat
	pushbytes 0x0000000000000003
	concat
	pushbytes 0x00000000000000c8
	concat
	retsub

// getNumValidators()uint64
*abi_route_getNumValidators:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNumValidators()uint64
	callsub getNumValidators
	itob
	concat
	log
	intc 1 // 1
	return

// getNumValidators(): uint64
//
// Returns the current number of validators
getNumValidators:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:292
	// return this.numValidators.value;
	bytec 12 //  "numV"
	app_global_get
	retsub

// getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
*abi_route_getValidatorConfig:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	callsub getValidatorConfig
	concat
	log
	intc 1 // 1
	return

// getValidatorConfig(validatorId: ValidatorIdType): ValidatorConfig
getValidatorConfig:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:297
	// return this.validatorList(validatorId).value.config;
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorState(uint64)(uint16,uint64,uint64,uint64)
*abi_route_getValidatorState:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorState(uint64)(uint16,uint64,uint64,uint64)
	callsub getValidatorState
	concat
	log
	intc 1 // 1
	return

// getValidatorState(validatorId: ValidatorIdType): ValidatorCurState
getValidatorState:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:302
	// return this.validatorList(validatorId).value.state;
	intc 8 //  headOffset
	pushint 26
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getValidatorOwnerAndManager(uint64)(address,address)
*abi_route_getValidatorOwnerAndManager:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getValidatorOwnerAndManager(uint64)(address,address)
	callsub getValidatorOwnerAndManager
	concat
	log
	intc 1 // 1
	return

// getValidatorOwnerAndManager(validatorId: ValidatorIdType): [Address, Address]
getValidatorOwnerAndManager:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:307
	// return [this.validatorList(validatorId).value.config.owner, this.validatorList(validatorId).value.config.manager];
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	concat
	retsub

// getPools(uint64)(uint64,uint16,uint64)[]
*abi_route_getPools:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPools(uint64)(uint64,uint16,uint64)[]
	callsub getPools
	dup
	len
	intc 5 // 18
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getPools(validatorId: ValidatorIdType): PoolInfo[]
//
// Return list of all pools for this validator.
// @param {uint64} validatorId
// @return {PoolInfo[]} - array of pools
// Not callable from other contracts because >1K return but can be called w/ simulate which bumps log returns
getPools:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:318
	// retData: PoolInfo[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: PoolInfo[]

	// examples/reti/validatorRegistry.algo.ts:319
	// poolSet = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 1 // poolSet: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:320
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_0:
	// examples/reti/validatorRegistry.algo.ts:320
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 3 // 24
	<
	bz *for_0_end

	// *if0_condition
	// examples/reti/validatorRegistry.algo.ts:321
	// poolSet[i].poolAppId === 0
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if0_end

	// *if0_consequent
	b *for_0_end

*if0_end:
	// examples/reti/validatorRegistry.algo.ts:325
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: PoolInfo[]
	frame_dig 1 // poolSet: (uint64,uint16,uint64)[24]
	frame_dig 2 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 5 // 18
	extract3
	concat
	frame_bury 0 // retData: PoolInfo[]

*for_0_continue:
	// examples/reti/validatorRegistry.algo.ts:320
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_0

*for_0_end:
	// examples/reti/validatorRegistry.algo.ts:327
	// return retData;
	frame_dig 0 // retData: PoolInfo[]

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getPoolAppId(uint64,uint64)uint64
*abi_route_getPoolAppId:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getPoolAppId(uint64,uint64)uint64
	callsub getPoolAppId
	itob
	concat
	log
	intc 1 // 1
	return

// getPoolAppId(validatorId: uint64, poolId: uint64): uint64
getPoolAppId:
	proto 2 1

	// examples/reti/validatorRegistry.algo.ts:335
	// assert(
	//       poolId !== 0 && poolId <= this.validatorList(validatorId).value.pools.length,
	//       'pool id must be between 1 and number of pools for this validator'
	//     )
	frame_dig -2 // poolId: uint64
	intc 0 // 0
	!=
	dup
	bz *skip_and0
	frame_dig -2 // poolId: uint64
	intc 3 // 24
	<=
	&&

*skip_and0:
	// pool id must be between 1 and number of pools for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:339
	// return this.validatorList(validatorId).value.pools[poolId - 1].poolAppId;
	intc 6 //  headOffset
	frame_dig -2 // poolId: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	btoi
	retsub

// getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
*abi_route_getPoolInfo:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 0 (poolKey) for getPoolInfo must be a (uint64,uint64,uint64)
	assert

	// execute getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)
	callsub getPoolInfo
	concat
	log
	intc 1 // 1
	return

// getPoolInfo(poolKey: ValidatorPoolKey): PoolInfo
getPoolInfo:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:344
	// return this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1];
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 5 // 18
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	retsub

// getCurMaxStakePerPool(uint64)uint64
*abi_route_getCurMaxStakePerPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getCurMaxStakePerPool(uint64)uint64
	callsub getCurMaxStakePerPool
	itob
	concat
	log
	intc 1 // 1
	return

// getCurMaxStakePerPool(validatorId: ValidatorIdType): uint64
//
// Calculate the maximum stake per pool for a given validator.
// Normally this would be maxAlgoPerPool, but it should also never go above MaxAllowedStake / numPools so
// as pools are added the max allowed per pool can reduce.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
getCurMaxStakePerPool:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:355
	// numPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:356
	// hardMaxDividedBetweenPools = this.maxAllowedStake() / numPools
	callsub maxAllowedStake
	frame_dig 0 // numPools: uint64
	/
	frame_bury 1 // hardMaxDividedBetweenPools: uint64

	// examples/reti/validatorRegistry.algo.ts:357
	// maxPerPool: uint64 = this.validatorList(validatorId).value.config.maxAlgoPerPool
	pushint 217
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // maxPerPool: uint64

	// *if1_condition
	// examples/reti/validatorRegistry.algo.ts:358
	// maxPerPool === 0
	frame_dig 2 // maxPerPool: uint64
	intc 0 // 0
	==
	bz *if1_end

	// *if1_consequent
	// examples/reti/validatorRegistry.algo.ts:359
	// maxPerPool = this.maxAlgoAllowedPerPool()
	callsub maxAlgoAllowedPerPool
	frame_bury 2 // maxPerPool: uint64

*if1_end:
	// *if2_condition
	// examples/reti/validatorRegistry.algo.ts:361
	// hardMaxDividedBetweenPools < maxPerPool
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_dig 2 // maxPerPool: uint64
	<
	bz *if2_end

	// *if2_consequent
	// examples/reti/validatorRegistry.algo.ts:362
	// maxPerPool = hardMaxDividedBetweenPools
	frame_dig 1 // hardMaxDividedBetweenPools: uint64
	frame_bury 2 // maxPerPool: uint64

*if2_end:
	// examples/reti/validatorRegistry.algo.ts:364
	// return maxPerPool;
	frame_dig 2 // maxPerPool: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// doesStakerNeedToPayMBR(address)bool
*abi_route_doesStakerNeedToPayMBR:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for doesStakerNeedToPayMBR must be a address
	assert

	// execute doesStakerNeedToPayMBR(address)bool
	callsub doesStakerNeedToPayMBR
	bytec 5 // 0x00
	intc 0 // 0
	uncover 2
	setbit
	concat
	log
	intc 1 // 1
	return

// doesStakerNeedToPayMBR(staker: Address): boolean
//
// Helper callers can call w/ simulate to determine if 'AddStaker' MBR should be included w/ staking amount
// @param staker
doesStakerNeedToPayMBR:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:373
	// return !this.stakerPoolSet(staker).exists;
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	retsub

// getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
*abi_route_getStakedPoolsForAccount:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// staker: address
	txna ApplicationArgs 1
	dup
	len
	intc 4 // 32
	==

	// argument 0 (staker) for getStakedPoolsForAccount must be a address
	assert

	// execute getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]
	callsub getStakedPoolsForAccount
	dup
	len
	intc 3 // 24
	/
	itob
	extract 6 2
	swap
	concat
	concat
	log
	intc 1 // 1
	return

// getStakedPoolsForAccount(staker: Address): ValidatorPoolKey[]
//
// Retrieves the staked pools for an account.
//
// @param {Address} staker - The account to retrieve staked pools for.
// @return {ValidatorPoolKey[]} - The array of staked pools for the account.
getStakedPoolsForAccount:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// *if3_condition
	// examples/reti/validatorRegistry.algo.ts:383
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	!
	bz *if3_end

	// *if3_consequent
	// examples/reti/validatorRegistry.algo.ts:384
	// return [];
	bytec 1 // 0x
	b *getStakedPoolsForAccount*return

*if3_end:
	// examples/reti/validatorRegistry.algo.ts:386
	// retData: ValidatorPoolKey[] = []
	bytec 1 // 0x
	frame_bury 0 // retData: ValidatorPoolKey[]

	// examples/reti/validatorRegistry.algo.ts:387
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 1 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:388
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_1:
	// examples/reti/validatorRegistry.algo.ts:388
	// i < poolSet.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_1_end

	// *if4_condition
	// examples/reti/validatorRegistry.algo.ts:389
	// poolSet[i].id !== 0
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	!=
	bz *if4_end

	// *if4_consequent
	// examples/reti/validatorRegistry.algo.ts:390
	// retData.push(clone(poolSet[i]))
	frame_dig 0 // retData: ValidatorPoolKey[]
	frame_dig 1 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	concat
	frame_bury 0 // retData: ValidatorPoolKey[]

*if4_end:

*for_1_continue:
	// examples/reti/validatorRegistry.algo.ts:388
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_1

*for_1_end:
	// examples/reti/validatorRegistry.algo.ts:393
	// return retData;
	frame_dig 0 // retData: ValidatorPoolKey[]

*getStakedPoolsForAccount*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// getTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_getTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub getTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// getTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// Retrieves the token payout ratio for a given validator - returning the pool ratios of whole so that token
// payouts across pools can be based on a stable snaphost of stake.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @return {PoolTokenPayoutRatio} - The token payout ratio for the validator.
getTokenPayoutRatio:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:405
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	retsub

// getNodePoolAssignments(uint64)((uint64[3])[8])
*abi_route_getNodePoolAssignments:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute getNodePoolAssignments(uint64)((uint64[3])[8])
	callsub getNodePoolAssignments
	concat
	log
	intc 1 // 1
	return

// getNodePoolAssignments(validatorId: uint64): NodePoolAssignmentConfig
getNodePoolAssignments:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:410
	// assert(this.validatorList(validatorId).exists, "the specified validator id doesn't exist")
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id doesn't exist
	assert

	// examples/reti/validatorRegistry.algo.ts:412
	// return this.validatorList(validatorId).value.nodePoolAssignments;
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: uint64
	itob
	concat
	cover 2
	box_extract
	retsub

// getNFDRegistryID()uint64
*abi_route_getNFDRegistryID:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// execute getNFDRegistryID()uint64
	callsub getNFDRegistryID
	itob
	concat
	log
	intc 1 // 1
	return

// getNFDRegistryID(): uint64
getNFDRegistryID:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:416
	// return this.nfdRegistryAppId;
	intc 19 // TMPL_nfdRegistryAppId
	retsub

// addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
*abi_route_addValidator:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	txna ApplicationArgs 2
	dup
	len
	intc 8 // 242
	==

	// argument 0 (config) for addValidator must be a (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	assert

	// nfdName: string
	txna ApplicationArgs 1
	extract 2 0

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addValidator must be a pay transaction
	assert

	// execute addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64
	callsub addValidator
	itob
	concat
	log
	intc 1 // 1
	return

// addValidator(mbrPayment: PayTxn, nfdName: string, config: ValidatorConfig): uint64
//
// Adds a new validator
// Requires at least 10 ALGO as the 'fee' for the transaction to help dissuade spammed validator adds.
//
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of new validator storage
// @param {string} nfdName (Optional) Name of nfd (used as double-check against id specified in config)
// @param {ValidatorConfig} config ValidatorConfig struct
// @returns {uint64} validator id
addValidator:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:428
	// this.validateConfig(config)
	frame_dig -3 // config: ValidatorConfig
	callsub validateConfig

	// examples/reti/validatorRegistry.algo.ts:429
	// assert(config.owner !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:430
	// assert(config.manager !== Address.zeroAddress)
	frame_dig -3 // config: ValidatorConfig
	extract 40 32
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:431
	// assert(this.txn.sender === config.owner, 'sender must be owner to add new validator')
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 8 32
	==

	// sender must be owner to add new validator
	assert

	// examples/reti/validatorRegistry.algo.ts:433
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addValidatorMbr })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 0 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addValidatorMbr"}
	assert

	// examples/reti/validatorRegistry.algo.ts:435
	// assert(mbrPayment.fee > 10 * 1000000, 'fee must be 10 ALGO or more to prevent spamming of validators')
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Fee
	pushint 10000000
	>

	// fee must be 10 ALGO or more to prevent spamming of validators
	assert

	// examples/reti/validatorRegistry.algo.ts:438
	// validatorId = this.numValidators.value + 1
	bytec 12 //  "numV"
	app_global_get
	intc 1 // 1
	+
	frame_bury 0 // validatorId: uint64

	// examples/reti/validatorRegistry.algo.ts:439
	// this.numValidators.value = validatorId
	bytec 12 //  "numV"
	frame_dig 0 // validatorId: uint64
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:441
	// this.validatorList(validatorId).create()
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	pushint 1092
	box_create
	pop

	// examples/reti/validatorRegistry.algo.ts:442
	// this.validatorList(validatorId).value.config = config
	intc 0 // 0
	frame_dig -3 // config: ValidatorConfig
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:443
	// this.validatorList(validatorId).value.config.id = validatorId
	intc 0 // 0
	frame_dig 0 // validatorId: uint64
	itob
	bytec 0 //  "v"
	frame_dig 0 // validatorId: uint64
	itob
	concat
	cover 2
	box_replace

	// *if5_condition
	// examples/reti/validatorRegistry.algo.ts:446
	// config.nfdForInfo !== 0
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	intc 0 // 0
	!=
	bz *if5_end

	// *if5_consequent
	// examples/reti/validatorRegistry.algo.ts:448
	// sendAppCall({
	//         applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//         applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)],
	//         applications: [AppID.fromUint64(config.nfdForInfo)],
	//       })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:449
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:450
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(config.nfdForInfo)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -2 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:451
	// applications: [AppID.fromUint64(config.nfdForInfo)]
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:453
	// assert(btoi(this.itxn.lastLog) === 1, "provided NFD isn't valid")
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// provided NFD isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:455
	// assert(
	//         this.txn.sender === (AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a') as Address),
	//         'If specifying NFD, account adding validator must be owner'
	//       )
	txn Sender
	frame_dig -3 // config: ValidatorConfig
	extract 72 8
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(config.nfdForInfo).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

*if5_end:
	// *if6_condition
	// examples/reti/validatorRegistry.algo.ts:461
	// config.entryGatingType === GATING_TYPE_CREATED_BY_NFD_ADDRESSES ||
	//       config.entryGatingType === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 9 // 3
	==
	dup
	bnz *skip_or0
	frame_dig -3 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	==
	||

*skip_or0:
	bz *if6_end

	// *if6_consequent
	// examples/reti/validatorRegistry.algo.ts:465
	// assert(this.isNFDAppIDValid(config.entryGatingAssets[0]), 'provided NFD App id for gating must be valid NFD')
	frame_dig -3 // config: ValidatorConfig
	extract 113 8
	btoi
	callsub isNFDAppIDValid

	// provided NFD App id for gating must be valid NFD
	assert

*if6_end:
	// examples/reti/validatorRegistry.algo.ts:468
	// return validatorId;
	frame_dig 0 // validatorId: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// changeValidatorManager(uint64,address)void
*abi_route_changeValidatorManager:
	// manager: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (manager) for changeValidatorManager must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorManager(uint64,address)void
	callsub changeValidatorManager
	intc 1 // 1
	return

// changeValidatorManager(validatorId: ValidatorIdType, manager: Address): void
//
// Changes the Validator manager for a specific Validator id.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to change the manager for.
// @param {Address} manager - The new manager address.
changeValidatorManager:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:479
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:483
	// this.validatorList(validatorId).value.config.manager = manager
	intc 17 // 40
	frame_dig -2 // manager: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorSunsetInfo(uint64,uint64,uint64)void
*abi_route_changeValidatorSunsetInfo:
	// sunsettingTo: uint64
	txna ApplicationArgs 3
	btoi

	// sunsettingOn: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorSunsetInfo(uint64,uint64,uint64)void
	callsub changeValidatorSunsetInfo
	intc 1 // 1
	return

// changeValidatorSunsetInfo(validatorId: ValidatorIdType, sunsettingOn: uint64, sunsettingTo: ValidatorIdType): void
//
// Updates the sunset information for a given validator.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} sunsettingOn - The new sunset timestamp.
// @param {uint64} sunsettingTo - The new sunset to validator id.
changeValidatorSunsetInfo:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:495
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:499
	// this.validatorList(validatorId).value.config.sunsettingOn = sunsettingOn
	intc 27 // 226
	frame_dig -2 // sunsettingOn: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:500
	// this.validatorList(validatorId).value.config.sunsettingTo = sunsettingTo
	pushint 234
	frame_dig -3 // sunsettingTo: ValidatorIdType
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorNFD(uint64,uint64,string)void
*abi_route_changeValidatorNFD:
	// nfdName: string
	txna ApplicationArgs 3
	extract 2 0

	// nfdAppID: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorNFD(uint64,uint64,string)void
	callsub changeValidatorNFD
	intc 1 // 1
	return

// changeValidatorNFD(validatorId: ValidatorIdType, nfdAppID: uint64, nfdName: string): void
//
// Changes the NFD for a validator in the validatorList contract.
// [ ONLY OWNER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator to update.
// @param {uint64} nfdAppID - The application id of the NFD to assign to the validator.
// @param {string} nfdName - The name of the NFD (which must match)
changeValidatorNFD:
	proto 3 0

	// examples/reti/validatorRegistry.algo.ts:513
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:518
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:519
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:520
	// applicationArgs: ['is_valid_nfd_appid', nfdName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig -3 // nfdName: string
	itxn_field ApplicationArgs
	frame_dig -2 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:521
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -2 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:524
	// assert(
	//       this.txn.sender === (AppID.fromUint64(nfdAppID).globalState('i.owner.a') as Address),
	//       'If specifying NFD, account adding validator must be owner'
	//     )
	txn Sender
	frame_dig -2 // nfdAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.owner.a')
	assert
	==

	// If specifying NFD, account adding validator must be owner
	assert

	// examples/reti/validatorRegistry.algo.ts:528
	// this.validatorList(validatorId).value.config.nfdForInfo = nfdAppID
	intc 21 // 72
	frame_dig -2 // nfdAppID: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorCommissionAddress(uint64,address)void
*abi_route_changeValidatorCommissionAddress:
	// commissionAddress: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (commissionAddress) for changeValidatorCommissionAddress must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorCommissionAddress(uint64,address)void
	callsub changeValidatorCommissionAddress
	intc 1 // 1
	return

// changeValidatorCommissionAddress(validatorId: ValidatorIdType, commissionAddress: Address): void
//
// Change the commission address that validator rewards are sent to.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorCommissionAddress:
	proto 2 0

	// examples/reti/validatorRegistry.algo.ts:536
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:540
	// assert(commissionAddress !== Address.zeroAddress)
	frame_dig -2 // commissionAddress: Address
	global ZeroAddress
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:541
	// this.validatorList(validatorId).value.config.validatorCommissionAddress = commissionAddress
	pushint 177
	frame_dig -2 // commissionAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
*abi_route_changeValidatorRewardInfo:
	// RewardPerPayout: uint64
	txna ApplicationArgs 6
	btoi

	// GatingAssetMinBalance: uint64
	txna ApplicationArgs 5
	btoi

	// EntryGatingAssets: uint64[4]
	txna ApplicationArgs 4
	dup
	len
	intc 4 // 32
	==

	// argument 2 (EntryGatingAssets) for changeValidatorRewardInfo must be a uint64[4]
	assert

	// EntryGatingAddress: address
	txna ApplicationArgs 3
	dup
	len
	intc 4 // 32
	==

	// argument 3 (EntryGatingAddress) for changeValidatorRewardInfo must be a address
	assert

	// EntryGatingType: uint8
	txna ApplicationArgs 2
	dup
	len
	intc 1 // 1
	==

	// argument 4 (EntryGatingType) for changeValidatorRewardInfo must be a uint8
	assert
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void
	callsub changeValidatorRewardInfo
	intc 1 // 1
	return

// changeValidatorRewardInfo(validatorId: ValidatorIdType, EntryGatingType: uint8, EntryGatingAddress: Address, EntryGatingAssets: StaticArray<uint64, 4>, GatingAssetMinBalance: uint64, RewardPerPayout: uint64): void
//
// Allow the additional rewards (gating entry, additional token rewards) information be changed at will.
// [ ONLY OWNER CAN CHANGE ]
changeValidatorRewardInfo:
	proto 6 0

	// examples/reti/validatorRegistry.algo.ts:556
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:561
	// this.validatorList(validatorId).value.config.entryGatingType = EntryGatingType
	intc 35 // 80
	frame_dig -2 // EntryGatingType: uint8
	itob
	extract 7 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:562
	// this.validatorList(validatorId).value.config.entryGatingAddress = EntryGatingAddress
	pushint 81
	frame_dig -3 // EntryGatingAddress: Address
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:563
	// this.validatorList(validatorId).value.config.entryGatingAssets = EntryGatingAssets
	pushint 113
	frame_dig -4 // EntryGatingAssets: StaticArray<uint64, 4>
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:564
	// this.validatorList(validatorId).value.config.gatingAssetMinBalance = GatingAssetMinBalance
	intc 36 // 145
	frame_dig -5 // GatingAssetMinBalance: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:565
	// this.validatorList(validatorId).value.config.rewardPerPayout = RewardPerPayout
	pushint 161
	frame_dig -6 // RewardPerPayout: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace
	retsub

// addPool(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addPool:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// nodeNum: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// mbrPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (mbrPayment) for addPool must be a pay transaction
	assert

	// execute addPool(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addPool
	concat
	log
	intc 1 // 1
	return

// addPool(mbrPayment: PayTxn, validatorId: ValidatorIdType, nodeNum: uint64): ValidatorPoolKey
//
// Adds a new pool to a validator's pool set, returning the 'key' to reference the pool in the future for staking, etc.
// The caller must pay the cost of the validators MBR increase as well as the MBR that will be needed for the pool itself.
//
// [ ONLY OWNER OR MANAGER CAN call ]
// @param {PayTxn} mbrPayment payment from caller which covers mbr increase of adding a new pool
// @param {uint64} validatorId is id of validator to pool to (must be owner or manager)
// @param {uint64} nodeNum is node number to add to
// @returns {ValidatorPoolKey} pool key to created pool
addPool:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:581
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or1
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or1:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:588
	// verifyPayTxn(mbrPayment, { amount: this.getMbrAmounts().addPoolMbr, receiver: this.app.address })
	// verify amount
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Amount
	callsub getMbrAmounts
	extract 8 8
	btoi
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"amount","expected":"this.getMbrAmounts().addPoolMbr"}
	assert

	// verify receiver
	frame_dig -1 // mbrPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"mbrPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:590
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:592
	// numPools: uint64 = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // numPools: uint64

	// *if7_condition
	// examples/reti/validatorRegistry.algo.ts:593
	// (numPools as uint64) >= MAX_POOLS
	frame_dig 0 // numPools: uint64
	intc 3 // 24
	>=
	bz *if7_end

	// *if7_consequent
	// already at max pool size
	err

*if7_end:
	// examples/reti/validatorRegistry.algo.ts:596
	// numPools += 1
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	+
	frame_bury 0 // numPools: uint64

	// examples/reti/validatorRegistry.algo.ts:599
	// sendAppCall({
	//       onCompletion: OnCompletion.NoOp,
	//       approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ],
	//       clearStateProgram: StakingPool.clearProgram(),
	//       globalNumUint: StakingPool.schema.global.numUint,
	//       globalNumByteSlice: StakingPool.schema.global.numByteSlice,
	//       extraProgramPages: 3,
	//       applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:600
	// onCompletion: OnCompletion.NoOp
	intc 0 //  NoOp
	itxn_field OnCompletion

	// examples/reti/validatorRegistry.algo.ts:601
	// approvalProgram: [
	//         this.stakingPoolApprovalProgram.extract(0, 4096),
	//         this.stakingPoolApprovalProgram.extract(4096, this.stakingPoolApprovalProgram.size - 4096),
	//       ]
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 0 // 0
	intc 25 // 4096
	box_extract
	itxn_field ApprovalProgramPages
	bytec 6 //  "poolTemplateApprovalBytes"
	intc 25 // 4096
	bytec 6 //  "poolTemplateApprovalBytes"
	box_len

	// box value does not exist: this.stakingPoolApprovalProgram.size
	assert
	intc 25 // 4096
	-
	box_extract
	itxn_field ApprovalProgramPages

	// examples/reti/validatorRegistry.algo.ts:605
	// clearStateProgram: StakingPool.clearProgram()
	pushbytes 0x0a
	itxn_field ClearStateProgram

	// examples/reti/validatorRegistry.algo.ts:606
	// globalNumUint: StakingPool.schema.global.numUint
	intc 34 // 11
	itxn_field GlobalNumUint

	// examples/reti/validatorRegistry.algo.ts:607
	// globalNumByteSlice: StakingPool.schema.global.numByteSlice
	intc 9 // 3
	itxn_field GlobalNumByteSlice

	// examples/reti/validatorRegistry.algo.ts:608
	// extraProgramPages: 3
	intc 9 // 3
	itxn_field ExtraProgramPages

	// examples/reti/validatorRegistry.algo.ts:609
	// applicationArgs: [
	//         // creatingContractID, validatorId, poolId, minEntryStake
	//         method('createApplication(uint64,uint64,uint64,uint64)void'),
	//         itob(this.app.id),
	//         itob(validatorId),
	//         itob(numPools as uint64),
	//         itob(this.validatorList(validatorId).value.config.minEntryStake),
	//       ]
	pushbytes 0x59e90aa6 // method "createApplication(uint64,uint64,uint64,uint64)void"
	itxn_field ApplicationArgs
	txna Applications 0
	itob
	itxn_field ApplicationArgs
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	itxn_field ApplicationArgs
	frame_dig 0 // numPools: uint64
	itob
	itxn_field ApplicationArgs
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:619
	// this.validatorList(validatorId).value.state.numPools = numPools as uint16
	intc 8 // 242
	frame_dig 0 // numPools: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:622
	// poolAppId = this.itxn.createdApplicationID.id
	itxn CreatedApplicationID
	frame_bury 1 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:623
	// this.validatorList(validatorId).value.pools[numPools - 1].poolAppId = poolAppId
	intc 6 //  headOffset
	frame_dig 0 // numPools: uint64
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 1 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:624
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig 1 // poolAppId: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:632
	// return { id: validatorId, poolId: numPools as uint64, poolAppId: this.itxn!.createdApplicationID.id };
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	frame_dig 0 // numPools: uint64
	itob
	concat
	itxn CreatedApplicationID
	itob
	concat

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 1
	retsub

// addStake(pay,uint64,uint64)(uint64,uint64,uint64)
*abi_route_addStake:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// valueToVerify: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// stakedAmountPayment: pay
	txn GroupIndex
	intc 1 // 1
	-
	dup
	gtxns TypeEnum
	intc 1 //  pay
	==

	// argument 2 (stakedAmountPayment) for addStake must be a pay transaction
	assert

	// execute addStake(pay,uint64,uint64)(uint64,uint64,uint64)
	callsub addStake
	concat
	log
	intc 1 // 1
	return

// addStake(stakedAmountPayment: PayTxn, validatorId: ValidatorIdType, valueToVerify: uint64): ValidatorPoolKey
//
// Adds stake to a validator pool.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - only if validator has gating to enter - this is asset id or nfd id that corresponds to gating.
// Txn sender is factored in as well if that is part of gating.
// * @returns {ValidatorPoolKey} - The key of the validator pool.
addStake:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 5

	// examples/reti/validatorRegistry.algo.ts:645
	// assert(this.validatorList(validatorId).exists, "specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	box_len
	swap
	pop

	// specified validator id isn't valid
	assert

	// *if8_condition
	// examples/reti/validatorRegistry.algo.ts:648
	// this.validatorList(validatorId).value.config.sunsettingOn > 0
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	>
	bz *if8_end

	// *if8_consequent
	// examples/reti/validatorRegistry.algo.ts:649
	// assert(
	//         this.validatorList(validatorId).value.config.sunsettingOn < globals.latestTimestamp,
	//         "can't stake with a validator that is past its sunsetting time"
	//       )
	intc 27 // 226
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	global LatestTimestamp
	<

	// can't stake with a validator that is past its sunsetting time
	assert

*if8_end:
	// examples/reti/validatorRegistry.algo.ts:655
	// staker = this.txn.sender
	txn Sender
	frame_bury 0 // staker: address

	// examples/reti/validatorRegistry.algo.ts:659
	// verifyPayTxn(stakedAmountPayment, {
	//       sender: staker,
	//       receiver: this.app.address,
	//     })
	// verify sender
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	frame_dig 0 // staker: address
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"sender","expected":"staker"}
	assert

	// verify receiver
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Receiver
	global CurrentApplicationAddress
	==

	// transaction verification failed: {"txn":"stakedAmountPayment","field":"receiver","expected":"this.app.address"}
	assert

	// examples/reti/validatorRegistry.algo.ts:666
	// assert(
	//       this.validatorList(validatorId).value.state.totalAlgoStaked < this.maxAllowedStake(),
	//       'total staked for all of a validators pools may not exceed hard cap'
	//     )
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	callsub maxAllowedStake
	<

	// total staked for all of a validators pools may not exceed hard cap
	assert

	// examples/reti/validatorRegistry.algo.ts:673
	// this.doesStakerMeetGating(validatorId, valueToVerify)
	frame_dig -3 // valueToVerify: uint64
	frame_dig -2 // validatorId: ValidatorIdType
	callsub doesStakerMeetGating

	// examples/reti/validatorRegistry.algo.ts:675
	// realAmount = stakedAmountPayment.amount
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:676
	// mbrAmtLeftBehind: uint64 = 0
	intc 0 // 0
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// *if9_condition
	// examples/reti/validatorRegistry.algo.ts:678
	// !this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	box_len
	swap
	pop
	!
	bz *if9_end

	// *if9_consequent
	// examples/reti/validatorRegistry.algo.ts:681
	// mbrAmtLeftBehind = this.getMbrAmounts().addStakerMbr
	callsub getMbrAmounts
	extract 24 8
	btoi
	frame_bury 2 // mbrAmtLeftBehind: uint64

	// examples/reti/validatorRegistry.algo.ts:682
	// realAmount -= mbrAmtLeftBehind
	frame_dig 1 // realAmount: uint64
	frame_dig 2 // mbrAmtLeftBehind: uint64
	-
	frame_bury 1 // realAmount: uint64

	// examples/reti/validatorRegistry.algo.ts:683
	// this.stakerPoolSet(staker).create()
	bytec 3 //  "sps"
	frame_dig 0 // staker: address
	concat
	pushint 144
	box_create
	pop

*if9_end:
	// examples/reti/validatorRegistry.algo.ts:687
	// findRet = this.findPoolForStaker(validatorId, staker, realAmount)
	frame_dig 1 // realAmount: uint64
	frame_dig 0 // staker: address
	frame_dig -2 // validatorId: ValidatorIdType
	callsub findPoolForStaker
	frame_bury 3 // findRet: ((uint64,uint64,uint64),bool,bool)

	// examples/reti/validatorRegistry.algo.ts:688
	// poolKey = findRet[0]
	// examples/reti/validatorRegistry.algo.ts:689
	// isNewStakerToValidator = findRet[1]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	intc 22 // 192
	getbit
	frame_bury 4 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:690
	// isNewStakerToProtocol = findRet[2]
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	pushint 193
	getbit
	frame_bury 5 // isNewStakerToProtocol: bool

	// *if10_condition
	// examples/reti/validatorRegistry.algo.ts:691
	// poolKey.poolId === 0
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 8 8
	btoi
	intc 0 // 0
	==
	bz *if10_end

	// *if10_consequent
	// No pool available with free stake.  Validator needs to add another pool
	err

*if10_end:
	// examples/reti/validatorRegistry.algo.ts:696
	// this.updateStakerPoolSet(staker, clone(poolKey))
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig 0 // staker: address
	callsub updateStakerPoolSet

	// examples/reti/validatorRegistry.algo.ts:699
	// this.callPoolAddStake(
	//       stakedAmountPayment,
	//       clone(poolKey),
	//       mbrAmtLeftBehind,
	//       isNewStakerToValidator,
	//       isNewStakerToProtocol
	//     )
	frame_dig 5 // isNewStakerToProtocol: bool
	frame_dig 4 // isNewStakerToValidator: bool
	frame_dig 2 // mbrAmtLeftBehind: uint64
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24
	frame_dig -1 // stakedAmountPayment: PayTxn
	callsub callPoolAddStake

	// examples/reti/validatorRegistry.algo.ts:714
	// return poolKey;
	frame_dig 3 // findRet: ((uint64,uint64,uint64),bool,bool)
	store 255 // full array
	load 255 // full array
	extract 0 24

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 5
	retsub

// setTokenPayoutRatio(uint64)(uint64[24],uint64)
*abi_route_setTokenPayoutRatio:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute setTokenPayoutRatio(uint64)(uint64[24],uint64)
	callsub setTokenPayoutRatio
	concat
	log
	intc 1 // 1
	return

// setTokenPayoutRatio(validatorId: ValidatorIdType): PoolTokenPayoutRatio
//
// setTokenPayoutRatio is called by Staking Pool # 1 (ONLY) to ask the validator (us) to calculate the ratios
// of stake in the pools for subsequent token payouts (ie: 2 pools, '100' algo total staked, 60 in pool 1, and 40
// in pool 2)  This is done so we have a stable snapshot of stake - taken once per epoch - only triggered by
// pool 1 doing payout.  pools other than 1 doing payout call pool 1 to ask it do it first.
// It would be 60/40% in the poolPctOfWhole values.  The token reward payouts then use these values instead of
// their 'current' stake which changes as part of the payouts themselves (and people could be changing stake
// during the epoch updates across pools)
//
// Multiple pools will call us via pool 1 (pool2->pool1->validator, etc.) so don't assert on pool1 calling multiple
// times in same epoch.  Just return.
//
// @param validatorId - validator id (and thus pool) calling us.  Verified so that sender MUST be pool 1 of this validator.
// @returns PoolTokenPayoutRatio - the finished ratio data
setTokenPayoutRatio:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:734
	// pool1AppID = this.validatorList(validatorId).value.pools[0].poolAppId
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // pool1AppID: uint64

	// examples/reti/validatorRegistry.algo.ts:735
	// assert(pool1AppID !== 0)
	frame_dig 0 // pool1AppID: uint64
	intc 0 // 0
	!=
	assert

	// *if11_condition
	// examples/reti/validatorRegistry.algo.ts:737
	// this.txn.sender !== AppID.fromUint64(pool1AppID).address
	txn Sender
	frame_dig 0 // pool1AppID: uint64
	app_params_get AppAddress
	pop
	!=
	bz *if11_end

	// *if11_consequent
	// examples/reti/validatorRegistry.algo.ts:738
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if11_end:
	// examples/reti/validatorRegistry.algo.ts:744
	// curRound = globals.round
	global Round
	frame_bury 1 // curRound: uint64

	// examples/reti/validatorRegistry.algo.ts:745
	// lastPayoutUpdate = this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout
	intc 30 // 892
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // lastPayoutUpdate: uint64

	// *if12_condition
	// examples/reti/validatorRegistry.algo.ts:746
	// lastPayoutUpdate !== 0
	frame_dig 2 // lastPayoutUpdate: uint64
	intc 0 // 0
	!=
	bz *if12_end

	// *if12_consequent
	// *if13_condition
	// examples/reti/validatorRegistry.algo.ts:748
	// (AppID.fromUint64(pool1AppID).globalState('lastPayout') as uint64) === lastPayoutUpdate
	frame_dig 0 // pool1AppID: uint64
	pushbytes 0x6c6173745061796f7574 // "lastPayout"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(pool1AppID).globalState('lastPayout')
	assert
	frame_dig 2 // lastPayoutUpdate: uint64
	==
	bz *if13_end

	// *if13_consequent
	// examples/reti/validatorRegistry.algo.ts:749
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if13_end:
	// examples/reti/validatorRegistry.algo.ts:751
	// epochRoundLength = this.validatorList(validatorId).value.config.epochRoundLength as uint64
	pushint 169
	intc 20 // 4
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // epochRoundLength: uint64

	// examples/reti/validatorRegistry.algo.ts:752
	// thisEpochBegin = curRound - (curRound % epochRoundLength)
	frame_dig 1 // curRound: uint64
	frame_dig 1 // curRound: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_bury 4 // thisEpochBegin: uint64

	// *if14_condition
	// examples/reti/validatorRegistry.algo.ts:754
	// lastPayoutUpdate - (lastPayoutUpdate % epochRoundLength) === thisEpochBegin
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 2 // lastPayoutUpdate: uint64
	frame_dig 3 // epochRoundLength: uint64
	%
	-
	frame_dig 4 // thisEpochBegin: uint64
	==
	bz *if14_end

	// *if14_consequent
	// examples/reti/validatorRegistry.algo.ts:755
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	b *setTokenPayoutRatio*return

*if14_end:

*if12_end:
	// examples/reti/validatorRegistry.algo.ts:758
	// this.validatorList(validatorId).value.tokenPayoutRatio.updatedForPayout = curRound
	intc 30 // 892
	frame_dig 1 // curRound: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:760
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 5 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:761
	// totalStakeForValidator = this.validatorList(validatorId).value.state.totalAlgoStaked
	intc 12 // 252
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // totalStakeForValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:762
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_2:
	// examples/reti/validatorRegistry.algo.ts:762
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 5 // curNumPools: uint64
	<
	bz *for_2_end

	// examples/reti/validatorRegistry.algo.ts:767
	// ourPoolPctOfWhole = wideRatio(
	//         [this.validatorList(validatorId).value.pools[i].totalAlgoStaked, 1_000_000],
	//         [totalStakeForValidator]
	//       )
	intc 6 //  headOffset
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	pushint 1_000_000
	mulw
	intc 0 // 0
	frame_dig 6 // totalStakeForValidator: uint64
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert
	frame_bury 8 // ourPoolPctOfWhole: uint64

	// examples/reti/validatorRegistry.algo.ts:771
	// this.validatorList(validatorId).value.tokenPayoutRatio.poolPctOfWhole[i] = ourPoolPctOfWhole
	intc 14 // 700
	frame_dig 7 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig 8 // ourPoolPctOfWhole: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*for_2_continue:
	// examples/reti/validatorRegistry.algo.ts:762
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_2

*for_2_end:
	// examples/reti/validatorRegistry.algo.ts:773
	// return this.validatorList(validatorId).value.tokenPayoutRatio;
	intc 14 //  headOffset
	intc 18 // 200
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract

*setTokenPayoutRatio*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 8
	retsub

// stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
*abi_route_stakeUpdatedViaRewards:
	// saturatedBurnToFeeSink: uint64
	txna ApplicationArgs 5
	btoi

	// validatorCommission: uint64
	txna ApplicationArgs 4
	btoi

	// rewardTokenAmountReserved: uint64
	txna ApplicationArgs 3
	btoi

	// algoToAdd: uint64
	txna ApplicationArgs 2
	btoi

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeUpdatedViaRewards must be a (uint64,uint64,uint64)
	assert

	// execute stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void
	callsub stakeUpdatedViaRewards
	intc 1 // 1
	return

// stakeUpdatedViaRewards(poolKey: ValidatorPoolKey, algoToAdd: uint64, rewardTokenAmountReserved: uint64, validatorCommission: uint64, saturatedBurnToFeeSink: uint64): void
//
// stakeUpdatedViaRewards is called by Staking pools to inform the validator (us) that a particular amount of total
// stake has been added to the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// The calling App id is validated against our pool list as well.
// @param {ValidatorPoolKey} poolKey - ValidatorPoolKey type
// @param {uint64} algoToAdd - amount this validator's total stake increased via rewards
// @param {uint64} rewardTokenAmountReserved - amount this validator's total stake increased via rewards (that should be
// @param {uint64} validatorCommission - the commission amount the validator was paid, if any
// @param {uint64} saturatedBurnToFeeSink - if the pool was in saturated state, the amount sent back to the fee sink.
// seen as 'accounted for/pending spent')
stakeUpdatedViaRewards:
	proto 5 0

	// examples/reti/validatorRegistry.algo.ts:794
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:797
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked += algoToAdd
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:798
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += algoToAdd
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -2 // algoToAdd: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:799
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack += rewardTokenAmountReserved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // rewardTokenAmountReserved: uint64
	+
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:801
	// this.totalAlgoStaked.value += algoToAdd
	bytec 4 //  "staked"
	app_global_get
	frame_dig -2 // algoToAdd: uint64
	+
	bytec 4 //  "staked"
	swap
	app_global_put

	// examples/reti/validatorRegistry.algo.ts:804
	// this.reverifyNFDOwnership(poolKey.id)
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	callsub reverifyNFDOwnership
	retsub

// stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
*abi_route_stakeRemoved:
	// stakerRemoved: bool
	txna ApplicationArgs 5
	dup
	len
	intc 1 // 1
	==

	// argument 0 (stakerRemoved) for stakeRemoved must be a bool
	assert
	intc 0 // 0
	getbit

	// rewardRemoved: uint64
	txna ApplicationArgs 4
	btoi

	// amountRemoved: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 3 (staker) for stakeRemoved must be a address
	assert

	// poolKey: (uint64,uint64,uint64)
	txna ApplicationArgs 1
	dup
	len
	intc 3 // 24
	==

	// argument 4 (poolKey) for stakeRemoved must be a (uint64,uint64,uint64)
	assert

	// execute stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void
	callsub stakeRemoved
	intc 1 // 1
	return

// stakeRemoved(poolKey: ValidatorPoolKey, staker: Address, amountRemoved: uint64, rewardRemoved: uint64, stakerRemoved: boolean): void
//
// stakeRemoved is called by Staking pools to inform the validator (us) that a particular amount of total stake has been removed
// from the specified pool.  This is used to update the stats we have in our PoolInfo storage.
// If any amount of rewardRemoved is specified, then that amount of reward is sent to the use
// The calling App id is validated against our pool list as well.
//
// @param {ValidatorPoolKey} poolKey calling us from which stake was removed
// @param {Address} staker
// @param {uint64} amountRemoved - algo amount removed
// @param {uint64} rewardRemoved - if applicable, amount of token reward removed (by pool 1 caller) or TO remove and pay out (via pool 1 from different pool caller)
// @param {boolean} stakerRemoved
stakeRemoved:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// *if15_condition
	// examples/reti/validatorRegistry.algo.ts:836
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if15_end

	// *if15_consequent
	// examples/reti/validatorRegistry.algo.ts:837
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if15_end:
	// examples/reti/validatorRegistry.algo.ts:839
	// this.verifyPoolKeyCaller(poolKey)
	frame_dig -1 // poolKey: ValidatorPoolKey
	callsub verifyPoolKeyCaller

	// examples/reti/validatorRegistry.algo.ts:843
	// assert(amountRemoved > 0 || rewardRemoved > 0, 'should only be called if algo or reward was removed')
	frame_dig -3 // amountRemoved: uint64
	intc 0 // 0
	>
	dup
	bnz *skip_or2
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	||

*skip_or2:
	// should only be called if algo or reward was removed
	assert

	// examples/reti/validatorRegistry.algo.ts:846
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked -= amountRemoved
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:847
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked -= amountRemoved
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:848
	// this.totalAlgoStaked.value -= amountRemoved
	bytec 4 //  "staked"
	app_global_get
	frame_dig -3 // amountRemoved: uint64
	-
	bytec 4 //  "staked"
	swap
	app_global_put

	// *if16_condition
	// examples/reti/validatorRegistry.algo.ts:850
	// rewardRemoved > 0
	frame_dig -4 // rewardRemoved: uint64
	intc 0 // 0
	>
	bz *if16_else

	// *if16_consequent
	// examples/reti/validatorRegistry.algo.ts:851
	// rewardTokenID = this.validatorList(poolKey.id).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenID: uint64

	// examples/reti/validatorRegistry.algo.ts:852
	// assert(rewardTokenID !== 0, "rewardRemoved can't be set if validator doesn't have reward token!")
	frame_dig 0 // rewardTokenID: uint64
	intc 0 // 0
	!=

	// rewardRemoved can't be set if validator doesn't have reward token!
	assert

	// examples/reti/validatorRegistry.algo.ts:853
	// assert(
	//         this.validatorList(poolKey.id).value.state.rewardTokenHeldBack >= rewardRemoved,
	//         'reward being removed must be covered by hold back amount'
	//       )
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	>=

	// reward being removed must be covered by hold back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:859
	// this.validatorList(poolKey.id).value.state.rewardTokenHeldBack -= rewardRemoved
	intc 13 // 260
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -4 // rewardRemoved: uint64
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if17_condition
	// examples/reti/validatorRegistry.algo.ts:864
	// poolKey.poolId !== 1
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	!=
	bz *if17_end

	// *if17_consequent
	// examples/reti/validatorRegistry.algo.ts:865
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//           applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId),
	//           methodArgs: [staker, rewardTokenID, rewardRemoved],
	//         })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:866
	// applicationID: AppID.fromUint64(this.validatorList(poolKey.id).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:867
	// methodArgs: [staker, rewardTokenID, rewardRemoved]
	frame_dig -2 // staker: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenID: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig -4 // rewardRemoved: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

*if17_end:
	b *if16_end

*if16_else:

*if16_end:
	// *if18_condition
	// examples/reti/validatorRegistry.algo.ts:892
	// stakerRemoved
	frame_dig -5 // stakerRemoved: boolean
	bz *if18_end

	// *if18_consequent
	// examples/reti/validatorRegistry.algo.ts:894
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers -= 1
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:896
	// removeRet = this.removeFromStakerPoolSet(staker, <ValidatorPoolKey>{
	//         id: poolKey.id,
	//         poolId: poolKey.poolId,
	//         poolAppId: poolKey.poolAppId,
	//       })
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	itob
	concat
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	itob
	concat
	frame_dig -2 // staker: Address
	callsub removeFromStakerPoolSet
	frame_bury 1 // removeRet: (bool,bool)

	// examples/reti/validatorRegistry.algo.ts:901
	// stakerOutOfThisValidator = removeRet[0]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 0 // 0
	getbit
	frame_bury 2 // stakerOutOfThisValidator: bool

	// examples/reti/validatorRegistry.algo.ts:902
	// stakerOutOfProtocol = removeRet[1]
	frame_dig 1 // removeRet: (bool,bool)
	store 255 // full array
	load 255 // full array
	intc 1 // 1
	getbit
	frame_bury 3 // stakerOutOfProtocol: bool

	// *if19_condition
	// examples/reti/validatorRegistry.algo.ts:904
	// stakerOutOfThisValidator
	frame_dig 2 // stakerOutOfThisValidator: bool
	bz *if19_end

	// *if19_consequent
	// examples/reti/validatorRegistry.algo.ts:905
	// this.validatorList(poolKey.id).value.state.totalStakers -= 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	-
	itob
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if19_end:
	// *if20_condition
	// examples/reti/validatorRegistry.algo.ts:908
	// stakerOutOfProtocol
	frame_dig 3 // stakerOutOfProtocol: bool
	bz *if20_end

	// *if20_consequent
	// examples/reti/validatorRegistry.algo.ts:909
	// this.numStakers.value -= 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	-
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if20_end:

*if18_end:
	retsub

// findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
*abi_route_findPoolForStaker:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// amountToStake: uint64
	txna ApplicationArgs 3
	btoi

	// staker: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 1 (staker) for findPoolForStaker must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)
	callsub findPoolForStaker
	concat
	log
	intc 1 // 1
	return

// findPoolForStaker(validatorId: ValidatorIdType, staker: Address, amountToStake: uint64): [ValidatorPoolKey, boolean, boolean]
//
// Finds the pool for a staker based on the provided validator id, staker address, and amount to stake.
// First checks the stakers 'already staked list' for the validator preferring those (adding if possible) then adds
// to new pool if necessary.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} staker - The address of the staker.
// @param {uint64} amountToStake - The amount to stake.
// @returns {ValidatorPoolKey, boolean, boolean} - The pool for the staker, true/false on whether the staker is 'new'
// to this VALIDATOR, and true/false if staker is new to the protocol.
findPoolForStaker:
	proto 3 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 7

	// examples/reti/validatorRegistry.algo.ts:930
	// isNewStakerToValidator = true
	intc 1 // 1
	frame_bury 0 // isNewStakerToValidator: bool

	// examples/reti/validatorRegistry.algo.ts:931
	// isNewStakerToProtocol = true
	intc 1 // 1
	frame_bury 1 // isNewStakerToProtocol: bool

	// examples/reti/validatorRegistry.algo.ts:939
	// maxPerPool = this.getCurMaxStakePerPool(validatorId)
	frame_dig -1 // validatorId: ValidatorIdType
	callsub getCurMaxStakePerPool
	frame_bury 2 // maxPerPool: uint64

	// *if21_condition
	// examples/reti/validatorRegistry.algo.ts:942
	// this.stakerPoolSet(staker).exists
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_len
	swap
	pop
	bz *if21_end

	// *if21_consequent
	// examples/reti/validatorRegistry.algo.ts:943
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -2 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:944
	// assert(validatorId !== 0)
	frame_dig -1 // validatorId: ValidatorIdType
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:945
	// for (let i = 0; i < poolSet.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_3:
	// examples/reti/validatorRegistry.algo.ts:945
	// i < poolSet.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_3_end

	// *if22_condition
	// examples/reti/validatorRegistry.algo.ts:946
	// globals.opcodeBudget < 300
	global OpcodeBudget
	intc 28 // 300
	<
	bz *if22_end

	// *if22_consequent
	// examples/reti/validatorRegistry.algo.ts:947
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if22_end:
	// *if23_condition
	// examples/reti/validatorRegistry.algo.ts:949
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if23_end

	// *if23_consequent
	b *for_3_continue

*if23_end:
	// examples/reti/validatorRegistry.algo.ts:952
	// isNewStakerToProtocol = false
	intc 0 // 0
	frame_bury 1 // isNewStakerToProtocol: bool

	// *if24_condition
	// examples/reti/validatorRegistry.algo.ts:953
	// poolSet[i].id === validatorId
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -1 // validatorId: ValidatorIdType
	==
	bz *if24_end

	// *if24_consequent
	// examples/reti/validatorRegistry.algo.ts:955
	// isNewStakerToValidator = false
	intc 0 // 0
	frame_bury 0 // isNewStakerToValidator: bool

	// *if25_condition
	// examples/reti/validatorRegistry.algo.ts:957
	// this.validatorList(validatorId).value.pools[poolSet[i].poolId - 1].totalAlgoStaked + amountToStake <=
	//             maxPerPool
	intc 6 //  headOffset
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 2 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if25_end

	// *if25_consequent
	// examples/reti/validatorRegistry.algo.ts:960
	// return [poolSet[i], isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if25_end:

*if24_end:

*for_3_continue:
	// examples/reti/validatorRegistry.algo.ts:945
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_3

*for_3_end:

*if21_end:
	// examples/reti/validatorRegistry.algo.ts:967
	// assert(
	//       amountToStake >= this.validatorList(validatorId).value.config.minEntryStake,
	//       'must stake at least the minimum for this pool'
	//     )
	frame_dig -3 // amountToStake: uint64
	intc 38 // 209
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	>=

	// must stake at least the minimum for this pool
	assert

	// examples/reti/validatorRegistry.algo.ts:973
	// pools = clone(this.validatorList(validatorId).value.pools)
	intc 6 //  headOffset
	intc 29 // 432
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 5 // pools: (uint64,uint16,uint64)[24]

	// examples/reti/validatorRegistry.algo.ts:974
	// curNumPools = this.validatorList(validatorId).value.state.numPools as uint64
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 6 // curNumPools: uint64

	// examples/reti/validatorRegistry.algo.ts:975
	// for (let i = 0; i < curNumPools; i += 1)
	intc 0 // 0
	frame_bury 7 // i: uint64

*for_4:
	// examples/reti/validatorRegistry.algo.ts:975
	// i < curNumPools
	frame_dig 7 // i: uint64
	frame_dig 6 // curNumPools: uint64
	<
	bz *for_4_end

	// *if26_condition
	// examples/reti/validatorRegistry.algo.ts:976
	// pools[i].totalAlgoStaked + amountToStake <= maxPerPool
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 11 //  headOffset
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -3 // amountToStake: uint64
	+
	frame_dig 2 // maxPerPool: uint64
	<=
	bz *if26_end

	// *if26_consequent
	// examples/reti/validatorRegistry.algo.ts:977
	// return [
	//           { id: validatorId, poolId: i + 1, poolAppId: pools[i].poolAppId },
	//           isNewStakerToValidator,
	//           isNewStakerToProtocol,
	//         ];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	itob
	concat
	frame_dig 5 // pools: (uint64,uint16,uint64)[24]
	frame_dig 7 // i: uint64
	intc 5 // 18
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	itob
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat
	b *findPoolForStaker*return

*if26_end:

*for_4_continue:
	// examples/reti/validatorRegistry.algo.ts:975
	// i += 1
	frame_dig 7 // i: uint64
	intc 1 // 1
	+
	frame_bury 7 // i: uint64
	b *for_4

*for_4_end:
	// examples/reti/validatorRegistry.algo.ts:985
	// return [{ id: validatorId, poolId: 0, poolAppId: 0 }, isNewStakerToValidator, isNewStakerToProtocol];
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	bytec 10 // 0x0000000000000000
	concat
	bytec 10 // 0x0000000000000000
	concat
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // isNewStakerToValidator: bool
	setbit
	intc 1 // 1
	frame_dig 1 // isNewStakerToProtocol: bool
	setbit
	concat

*findPoolForStaker*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 7
	retsub

// movePoolToNode(uint64,uint64,uint64)void
*abi_route_movePoolToNode:
	// nodeNum: uint64
	txna ApplicationArgs 3
	btoi

	// poolAppId: uint64
	txna ApplicationArgs 2
	btoi

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute movePoolToNode(uint64,uint64,uint64)void
	callsub movePoolToNode
	intc 1 // 1
	return

// movePoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
//
// Find the specified pool (in any node number) and move it to the specified node.
// The pool account is forced offline if moved so prior node will still run for 320 rounds but
// new key goes online on new node soon after (320 rounds after it goes online)
// No-op if success, asserts if not found or can't move  (no space in target)
// [ ONLY OWNER OR MANAGER CAN CHANGE ]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} poolAppId
// @param {uint64} nodeNum
movePoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1001
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner ||
	//         this.txn.sender === this.validatorList(validatorId).value.config.manager,
	//       'can only be called by owner or manager of validator'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	dup
	bnz *skip_or3
	txn Sender
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==
	||

*skip_or3:
	// can only be called by owner or manager of validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1007
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1008
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number out of allowable range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and1
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and1:
	// node number out of allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1010
	// for (let srcNodeIdx = 0; srcNodeIdx < MAX_NODES; srcNodeIdx += 1)
	intc 0 // 0
	frame_bury 1 // srcNodeIdx: uint64

*for_5:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx < MAX_NODES
	frame_dig 1 // srcNodeIdx: uint64
	intc 2 // 8
	<
	bz *for_5_end

	// examples/reti/validatorRegistry.algo.ts:1011
	// for (let i = 0; i < MAX_POOLS_PER_NODE; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_6:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i < MAX_POOLS_PER_NODE
	frame_dig 2 // i: uint64
	intc 9 // 3
	<
	bz *for_6_end

	// *if27_condition
	// examples/reti/validatorRegistry.algo.ts:1012
	// nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] === poolAppId
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolAppId: uint64
	==
	bz *if27_end

	// *if27_consequent
	// examples/reti/validatorRegistry.algo.ts:1013
	// assert(nodeNum - 1 !== srcNodeIdx, "can't move to same node")
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	frame_dig 1 // srcNodeIdx: uint64
	!=

	// can't move to same node
	assert

	// examples/reti/validatorRegistry.algo.ts:1015
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[srcNodeIdx].poolAppIds[i] = 0
	intc 16 // 900
	frame_dig 1 // srcNodeIdx: uint64
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1018
	// sendMethodCall<typeof StakingPool.prototype.goOffline>({
	//             applicationID: AppID.fromUint64(poolAppId),
	//           })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0x51ef3b21 // method "goOffline()void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1019
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig -2 // poolAppId: uint64
	itxn_field ApplicationID

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1023
	// this.addPoolToNode(validatorId, poolAppId, nodeNum)
	frame_dig -3 // nodeNum: uint64
	frame_dig -2 // poolAppId: uint64
	frame_dig -1 // validatorId: ValidatorIdType
	callsub addPoolToNode

	// examples/reti/validatorRegistry.algo.ts:1024
	// return;
	retsub

*if27_end:

*for_6_continue:
	// examples/reti/validatorRegistry.algo.ts:1011
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_6

*for_6_end:

*for_5_continue:
	// examples/reti/validatorRegistry.algo.ts:1010
	// srcNodeIdx += 1
	frame_dig 1 // srcNodeIdx: uint64
	intc 1 // 1
	+
	frame_bury 1 // srcNodeIdx: uint64
	b *for_5

*for_5_end:
	// couldn't find pool app id in nodes to move
	err
	retsub

// emptyTokenRewards(uint64,address)uint64
*abi_route_emptyTokenRewards:
	// The ABI return prefix
	bytec 2 // 0x151f7c75

	// receiver: address
	txna ApplicationArgs 2
	dup
	len
	intc 4 // 32
	==

	// argument 0 (receiver) for emptyTokenRewards must be a address
	assert

	// validatorId: uint64
	txna ApplicationArgs 1
	btoi

	// execute emptyTokenRewards(uint64,address)uint64
	callsub emptyTokenRewards
	itob
	concat
	log
	intc 1 // 1
	return

// emptyTokenRewards(validatorId: ValidatorIdType, receiver: Address): uint64
//
// Sends the reward tokens held in pool 1 to specified receiver.
// This is intended to be used by the owner when they want to get reward tokens 'back' which they sent to
// the first pool (likely because validator is sunsetting.  Any tokens currently 'reserved' for stakers to claim will
// NOT be sent as they must be held back for stakers to later claim.
// [ ONLY OWNER CAN CALL]
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {Address} receiver - the account to send the tokens to (must already be opted-in to the reward token)
// @returns {uint64} the amount of reward token sent
emptyTokenRewards:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 3

	// examples/reti/validatorRegistry.algo.ts:1043
	// assert(
	//       this.txn.sender === this.validatorList(validatorId).value.config.owner,
	//       'can only be called by validator owner'
	//     )
	txn Sender
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	==

	// can only be called by validator owner
	assert

	// examples/reti/validatorRegistry.algo.ts:1047
	// rewardTokenId = this.validatorList(validatorId).value.config.rewardTokenId
	intc 37 // 153
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // rewardTokenId: uint64

	// examples/reti/validatorRegistry.algo.ts:1048
	// rewardTokenHeldBack = this.validatorList(validatorId).value.state.rewardTokenHeldBack
	intc 13 // 260
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // rewardTokenHeldBack: uint64

	// examples/reti/validatorRegistry.algo.ts:1049
	// assert(rewardTokenId !== 0, "this validator doesn't have a reward token defined")
	frame_dig 0 // rewardTokenId: uint64
	intc 0 // 0
	!=

	// this validator doesn't have a reward token defined
	assert

	// examples/reti/validatorRegistry.algo.ts:1050
	// poolOneAppId = AppID.fromUint64(this.validatorList(validatorId).value.pools[0].poolAppId)
	intc 6 // 268
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 2 // poolOneAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1052
	// tokenRewardBal = poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) - rewardTokenHeldBack
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	-
	frame_bury 3 // tokenRewardBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1055
	// sendMethodCall<typeof StakingPool.prototype.payTokenReward>({
	//       applicationID: poolOneAppId,
	//       methodArgs: [receiver, rewardTokenId, tokenRewardBal],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	bytec 14 //  method "payTokenReward(address,uint64,uint64)void"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1056
	// applicationID: poolOneAppId
	frame_dig 2 // poolOneAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1057
	// methodArgs: [receiver, rewardTokenId, tokenRewardBal]
	frame_dig -2 // receiver: Address
	itxn_field ApplicationArgs
	frame_dig 0 // rewardTokenId: uint64
	itob
	itxn_field ApplicationArgs
	frame_dig 3 // tokenRewardBal: uint64
	itob
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1059
	// assert(
	//       poolOneAppId.address.assetBalance(AssetID.fromUint64(rewardTokenId)) === rewardTokenHeldBack,
	//       'balance of remaining reward tokens should match the held back amount'
	//     )
	frame_dig 2 // poolOneAppId: uint64
	app_params_get AppAddress
	pop
	frame_dig 0 // rewardTokenId: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 1 // rewardTokenHeldBack: uint64
	==

	// balance of remaining reward tokens should match the held back amount
	assert

	// examples/reti/validatorRegistry.algo.ts:1063
	// return tokenRewardBal;
	frame_dig 3 // tokenRewardBal: uint64

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 3
	retsub

// verifyPoolKeyCaller(poolKey: ValidatorPoolKey): void
//
// Logs the addition of a new validator to the system, its initial owner and manager
//
//
// verifyPoolKeyCaller verifies the passed in key (from a staking pool calling us to update metrics) is valid
// and matches the information we have in our state.  'Fake' pools could call us to update our data, but they
// can't fake the ids and most importantly application id(!) of the caller that has to match.
verifyPoolKeyCaller:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1161
	// assert(this.validatorList(poolKey.id).exists, "the specified validator id isn't valid")
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	box_len
	swap
	pop

	// the specified validator id isn't valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1162
	// assert(poolKey.poolId <= MAX_POOLS, 'pool id not in valid range')
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 3 // 24
	<=

	// pool id not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1163
	// assert(
	//       poolKey.poolId > 0 && (poolKey.poolId as uint16) <= this.validatorList(poolKey.id).value.state.numPools,
	//       'pool id outside of range of pools created for this validator'
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and2
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 8 // 242
	intc 10 // 2
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	<=
	&&

*skip_and2:
	// pool id outside of range of pools created for this validator
	assert

	// examples/reti/validatorRegistry.algo.ts:1169
	// assert(
	//       poolKey.poolAppId === this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId,
	//       "The passed in app id doesn't match the passed in ids"
	//     )
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	intc 6 //  headOffset
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	==

	// The passed in app id doesn't match the passed in ids
	assert

	// examples/reti/validatorRegistry.algo.ts:1174
	// assert(this.txn.sender === AppID.fromUint64(poolKey.poolAppId).address)
	txn Sender
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	app_params_get AppAddress
	pop
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1176
	// assert(poolKey.id === (AppID.fromUint64(poolKey.poolAppId).globalState('validatorId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x76616c696461746f724964 // "validatorId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('validatorId')
	assert
	==
	assert

	// examples/reti/validatorRegistry.algo.ts:1177
	// assert(poolKey.poolId === (AppID.fromUint64(poolKey.poolAppId).globalState('poolId') as uint64))
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	frame_dig -1 // poolKey: ValidatorPoolKey
	extract 16 8
	btoi
	pushbytes 0x706f6f6c4964 // "poolId"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolKey.poolAppId).globalState('poolId')
	assert
	==
	assert
	retsub

// reverifyNFDOwnership(validatorId: ValidatorIdType): void
//
// This method verifies the ownership of NFD (Named Function Data) by a validator.
// If the ownership is no longer valid, it removes the NFD from the validator's configuration.
//
// @param {ValidatorIdType} validatorId - The id of the validator whose data should be re-evaluated.
reverifyNFDOwnership:
	proto 1 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dup

	// examples/reti/validatorRegistry.algo.ts:1187
	// validatorConfig = this.validatorList(validatorId).value.config
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	frame_bury 0 // storage key//validatorConfig

	// *if28_condition
	// examples/reti/validatorRegistry.algo.ts:1188
	// validatorConfig.nfdForInfo !== 0
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 0 // 0
	!=
	bz *if28_end

	// *if28_consequent
	// examples/reti/validatorRegistry.algo.ts:1191
	// nfdOwner = AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a') as Address
	intc 21 // 72
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(validatorConfig.nfdForInfo).globalState('i.owner.a')
	assert
	frame_bury 1 // nfdOwner: address

	// *if29_condition
	// examples/reti/validatorRegistry.algo.ts:1193
	// validatorConfig.owner !== nfdOwner && validatorConfig.manager !== nfdOwner
	intc 2 // 8
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	dup
	bz *skip_and3
	intc 17 // 40
	intc 4 // 32
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_dig 1 // nfdOwner: address
	!=
	&&

*skip_and3:
	bz *if29_end

	// *if29_consequent
	// examples/reti/validatorRegistry.algo.ts:1195
	// this.validatorList(validatorId).value.config.nfdForInfo = 0
	intc 21 // 72
	bytec 10 // 0x0000000000000000
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

*if29_end:

*if28_end:
	retsub

// validateConfig(config: ValidatorConfig): void
validateConfig:
	proto 1 0

	// examples/reti/validatorRegistry.algo.ts:1202
	// assert(
	//       config.entryGatingType >= GATING_TYPE_NONE && config.entryGatingType <= GATING_TYPE_CONST_MAX,
	//       'gating type not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and4
	frame_dig -1 // config: ValidatorConfig
	extract 80 1
	btoi
	intc 20 // 4
	<=
	&&

*skip_and4:
	// gating type not valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1206
	// assert(
	//       config.epochRoundLength >= MIN_EPOCH_LENGTH && config.epochRoundLength <= MAX_EPOCH_LENGTH,
	//       'epoch length not in allowable range'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 1 // 1
	>=
	dup
	bz *skip_and5
	frame_dig -1 // config: ValidatorConfig
	extract 169 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and5:
	// epoch length not in allowable range
	assert

	// examples/reti/validatorRegistry.algo.ts:1210
	// assert(
	//       config.percentToValidator >= MIN_PCT_TO_VALIDATOR && config.percentToValidator <= MAX_PCT_TO_VALIDATOR,
	//       'commission percentage not valid'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	>=
	dup
	bz *skip_and6
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 24 // 1000000
	<=
	&&

*skip_and6:
	// commission percentage not valid
	assert

	// *if30_condition
	// examples/reti/validatorRegistry.algo.ts:1214
	// config.percentToValidator !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 173 4
	btoi
	intc 0 // 0
	!=
	bz *if30_end

	// *if30_consequent
	// examples/reti/validatorRegistry.algo.ts:1215
	// assert(
	//         config.validatorCommissionAddress !== Address.zeroAddress,
	//         'validatorCommissionAddress must be set if percent to validator is not 0'
	//       )
	frame_dig -1 // config: ValidatorConfig
	extract 177 32
	global ZeroAddress
	!=

	// validatorCommissionAddress must be set if percent to validator is not 0
	assert

*if30_end:
	// examples/reti/validatorRegistry.algo.ts:1220
	// assert(config.minEntryStake >= MIN_ALGO_STAKE_PER_POOL, 'staking pool must have minimum entry of 1 algo')
	frame_dig -1 // config: ValidatorConfig
	extract 209 8
	btoi
	intc 24 // 1000000
	>=

	// staking pool must have minimum entry of 1 algo
	assert

	// examples/reti/validatorRegistry.algo.ts:1222
	// assert(
	//       config.poolsPerNode > 0 && config.poolsPerNode <= MAX_POOLS_PER_NODE,
	//       'number of pools per node exceeds allowed number'
	//     )
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 0 // 0
	>
	dup
	bz *skip_and7
	frame_dig -1 // config: ValidatorConfig
	extract 225 1
	btoi
	intc 9 // 3
	<=
	&&

*skip_and7:
	// number of pools per node exceeds allowed number
	assert

	// *if31_condition
	// examples/reti/validatorRegistry.algo.ts:1226
	// config.sunsettingOn !== 0
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	intc 0 // 0
	!=
	bz *if31_end

	// *if31_consequent
	// examples/reti/validatorRegistry.algo.ts:1227
	// assert(config.sunsettingOn > globals.latestTimestamp, 'sunsettingOn must be later than now if set')
	frame_dig -1 // config: ValidatorConfig
	extract 226 8
	btoi
	global LatestTimestamp
	>

	// sunsettingOn must be later than now if set
	assert

*if31_end:
	retsub

// callPoolAddStake(stakedAmountPayment: PayTxn, poolKey: ValidatorPoolKey, mbrAmtPaid: uint64, isNewStakerToValidator: boolean, isNewStakerToProtocol: boolean): void
//
// Adds a stakers amount of algo to a validator pool, transferring the algo we received from them (already verified
// by our caller) to the staking pool account, and then telling it about the amount being added for the specified
// staker.
//
// @param {PayTxn} stakedAmountPayment - payment coming from staker to place into a pool
// @param {ValidatorPoolKey} poolKey - The key of the validator pool.
// @param {uint64} mbrAmtPaid - Amount the user is leaving behind in the validator to pay for their staker MBR cost
// @param {boolean} isNewStakerToValidator - if this is a new, first-time staker to the validator
// @param {boolean} isNewStakerToProtocol - if this is a new, first-time staker to the protocol
callPoolAddStake:
	proto 5 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1249
	// poolAppId = this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].poolAppId
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 0 // 0
	+
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // poolAppId: uint64

	// examples/reti/validatorRegistry.algo.ts:1253
	// sendMethodCall<typeof StakingPool.prototype.addStake, uint64>({
	//       applicationID: AppID.fromUint64(poolAppId),
	//       methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ],
	//     })
	itxn_begin
	intc 1 //  pay
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1258
	// amount: stakedAmountPayment.amount - mbrAmtPaid
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	itxn_field Amount

	// examples/reti/validatorRegistry.algo.ts:1258
	// receiver: AppID.fromUint64(poolAppId).address
	frame_dig 0 // poolAppId: uint64
	app_params_get AppAddress
	pop
	itxn_field Receiver

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee
	itxn_next
	intc 7 //  appl
	itxn_field TypeEnum
	pushbytes 0xf9c70cbd // method "addStake(pay,address)uint64"
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1254
	// applicationID: AppID.fromUint64(poolAppId)
	frame_dig 0 // poolAppId: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1255
	// methodArgs: [
	//         // =======
	//         // THIS IS A SEND of the amount received right back out and into the staking pool contract account.
	//         { amount: stakedAmountPayment.amount - mbrAmtPaid, receiver: AppID.fromUint64(poolAppId).address },
	//         // =======
	//         stakedAmountPayment.sender,
	//       ]
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Sender
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit
	itxn NumLogs
	intc 1 // 1
	-
	itxnas Logs
	extract 4 0
	btoi

	// *if32_condition
	// examples/reti/validatorRegistry.algo.ts:1263
	// globals.opcodeBudget < 500
	global OpcodeBudget
	pushint 500
	<
	bz *if32_end

	// *if32_consequent
	// examples/reti/validatorRegistry.algo.ts:1264
	// increaseOpcodeBudget()
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum
	intc 0 // 0
	itxn_field Fee
	bytec 8 //  #pragma version 10; int 1
	dup
	itxn_field ApprovalProgram
	itxn_field ClearStateProgram
	intc 26 //  DeleteApplication
	itxn_field OnCompletion
	itxn_submit

*if32_end:
	// examples/reti/validatorRegistry.algo.ts:1268
	// poolNumStakers = AppID.fromUint64(poolAppId).globalState('numStakers') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 7 //  "numStakers"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('numStakers')
	assert
	frame_bury 1 // poolNumStakers: uint64

	// examples/reti/validatorRegistry.algo.ts:1269
	// poolAlgoStaked = AppID.fromUint64(poolAppId).globalState('staked') as uint64
	frame_dig 0 // poolAppId: uint64
	bytec 4 //  "staked"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(poolAppId).globalState('staked')
	assert
	frame_bury 2 // poolAlgoStaked: uint64

	// examples/reti/validatorRegistry.algo.ts:1270
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalStakers = poolNumStakers as uint16
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 2 //  headOffset
	+
	frame_dig 1 // poolNumStakers: uint64
	itob
	extract 6 2
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1271
	// this.validatorList(poolKey.id).value.pools[poolKey.poolId - 1].totalAlgoStaked = poolAlgoStaked
	intc 6 //  headOffset
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 8 8
	btoi
	intc 1 // 1
	-
	intc 5 // 18
	* // acc * typeLength
	+
	intc 11 //  headOffset
	+
	frame_dig 2 // poolAlgoStaked: uint64
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// *if33_condition
	// examples/reti/validatorRegistry.algo.ts:1274
	// isNewStakerToValidator
	frame_dig -4 // isNewStakerToValidator: boolean
	bz *if33_end

	// *if33_consequent
	// examples/reti/validatorRegistry.algo.ts:1275
	// this.validatorList(poolKey.id).value.state.totalStakers += 1
	intc 23 // 244
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	intc 1 // 1
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

*if33_end:
	// *if34_condition
	// examples/reti/validatorRegistry.algo.ts:1277
	// isNewStakerToProtocol
	frame_dig -5 // isNewStakerToProtocol: boolean
	bz *if34_end

	// *if34_consequent
	// examples/reti/validatorRegistry.algo.ts:1278
	// this.numStakers.value += 1
	bytec 7 //  "numStakers"
	app_global_get
	intc 1 // 1
	+
	bytec 7 //  "numStakers"
	swap
	app_global_put

*if34_end:
	// examples/reti/validatorRegistry.algo.ts:1280
	// this.validatorList(poolKey.id).value.state.totalAlgoStaked += stakedAmountPayment.amount - mbrAmtPaid
	intc 12 // 252
	dup
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	itob
	bytec 0 //  "v"
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1281
	// this.totalAlgoStaked.value += stakedAmountPayment.amount - mbrAmtPaid
	bytec 4 //  "staked"
	app_global_get
	frame_dig -1 // stakedAmountPayment: PayTxn
	gtxns Amount
	frame_dig -3 // mbrAmtPaid: uint64
	-
	+
	bytec 4 //  "staked"
	swap
	app_global_put
	retsub

// updateStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): void
updateStakerPoolSet:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1285
	// assert(this.stakerPoolSet(staker).exists)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_len
	swap
	pop
	assert

	// examples/reti/validatorRegistry.algo.ts:1287
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 0 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1288
	// firstEmpty = 0
	intc 0 // 0
	frame_bury 1 // firstEmpty: uint64

	// examples/reti/validatorRegistry.algo.ts:1289
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_7:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 2 // i: uint64
	intc 7 // 6
	<
	bz *for_7_end

	// *if35_condition
	// examples/reti/validatorRegistry.algo.ts:1290
	// poolSet[i] === poolKey
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if35_end

	// *if35_consequent
	// examples/reti/validatorRegistry.algo.ts:1292
	// return;
	retsub

*if35_end:
	// *if36_condition
	// examples/reti/validatorRegistry.algo.ts:1294
	// firstEmpty === 0 && poolSet[i].id === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	dup
	bz *skip_and8
	frame_dig 0 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 2 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	&&

*skip_and8:
	bz *if36_end

	// *if36_consequent
	// examples/reti/validatorRegistry.algo.ts:1295
	// firstEmpty = i + 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 1 // firstEmpty: uint64

*if36_end:

*for_7_continue:
	// examples/reti/validatorRegistry.algo.ts:1289
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_7

*for_7_end:
	// *if37_condition
	// examples/reti/validatorRegistry.algo.ts:1298
	// firstEmpty === 0
	frame_dig 1 // firstEmpty: uint64
	intc 0 // 0
	==
	bz *if37_end

	// *if37_consequent
	// No empty slot available in the staker pool set
	err

*if37_end:
	// examples/reti/validatorRegistry.algo.ts:1301
	// this.stakerPoolSet(staker).value[firstEmpty - 1] = poolKey
	frame_dig 1 // firstEmpty: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	frame_dig -2 // poolKey: ValidatorPoolKey
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	retsub

// removeFromStakerPoolSet(staker: Address, poolKey: ValidatorPoolKey): [boolean, boolean]
//
// Removes a pool key from the staker's active pool set - fails if not found (!)
//
// @param {Address} staker - The address of the staker.
// @param {ValidatorPoolKey} poolKey - The pool key they should be stored in
//
// @return [boolean, boolean] [is the staker gone from ALL pools of the given VALIDATOR, and is staker gone from ALL pools]
removeFromStakerPoolSet:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 4

	// examples/reti/validatorRegistry.algo.ts:1314
	// inSameValidatorPoolCount = 0
	intc 0 // 0
	frame_bury 0 // inSameValidatorPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1315
	// inAnyPoolCount = 0
	intc 0 // 0
	frame_bury 1 // inAnyPoolCount: uint64

	// examples/reti/validatorRegistry.algo.ts:1316
	// found = false
	intc 0 // 0
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1318
	// poolSet = clone(this.stakerPoolSet(staker).value)
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	box_get

	// box value does not exist: this.stakerPoolSet(staker).value
	assert
	frame_bury 3 // poolSet: (uint64,uint64,uint64)[6]

	// examples/reti/validatorRegistry.algo.ts:1319
	// for (let i = 0; i < this.stakerPoolSet(staker).value.length; i += 1)
	intc 0 // 0
	frame_bury 4 // i: uint64

*for_8:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i < this.stakerPoolSet(staker).value.length
	frame_dig 4 // i: uint64
	intc 7 // 6
	<
	bz *for_8_end

	// *if38_condition
	// examples/reti/validatorRegistry.algo.ts:1320
	// poolSet[i].id === 0
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if38_end

	// *if38_consequent
	b *for_8_continue

*if38_end:
	// examples/reti/validatorRegistry.algo.ts:1323
	// inAnyPoolCount += 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 1 // inAnyPoolCount: uint64

	// *if39_condition
	// examples/reti/validatorRegistry.algo.ts:1324
	// poolSet[i].id === poolKey.id
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 0 // 0
	+
	intc 2 // 8
	extract3
	btoi
	frame_dig -2 // poolKey: ValidatorPoolKey
	extract 0 8
	btoi
	==
	bz *if39_end

	// *if39_consequent
	// *if40_condition
	// examples/reti/validatorRegistry.algo.ts:1325
	// poolSet[i] === poolKey
	frame_dig 3 // poolSet: (uint64,uint64,uint64)[6]
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	intc 3 // 24
	extract3
	frame_dig -2 // poolKey: ValidatorPoolKey
	==
	bz *if40_else

	// *if40_consequent
	// examples/reti/validatorRegistry.algo.ts:1326
	// found = true
	intc 1 // 1
	frame_bury 2 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1328
	// this.stakerPoolSet(staker).value[i] = { id: 0, poolId: 0, poolAppId: 0 }
	frame_dig 4 // i: uint64
	intc 3 // 24
	* // acc * typeLength
	pushbytes 0x000000000000000000000000000000000000000000000000
	bytec 3 //  "sps"
	frame_dig -1 // staker: Address
	concat
	cover 2
	box_replace
	b *if40_end

*if40_else:
	// examples/reti/validatorRegistry.algo.ts:1330
	// inSameValidatorPoolCount += 1
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 1 // 1
	+
	frame_bury 0 // inSameValidatorPoolCount: uint64

*if40_end:

*if39_end:

*for_8_continue:
	// examples/reti/validatorRegistry.algo.ts:1319
	// i += 1
	frame_dig 4 // i: uint64
	intc 1 // 1
	+
	frame_bury 4 // i: uint64
	b *for_8

*for_8_end:
	// *if41_condition
	// examples/reti/validatorRegistry.algo.ts:1334
	// !found
	frame_dig 2 // found: bool
	!
	bz *if41_end

	// *if41_consequent
	// No matching slot found when told to remove a pool from the stakers set
	err

*if41_end:
	// examples/reti/validatorRegistry.algo.ts:1338
	// return [inSameValidatorPoolCount === 0, inAnyPoolCount === 0];
	bytec 5 // 0x00
	intc 0 // 0
	frame_dig 0 // inSameValidatorPoolCount: uint64
	intc 0 // 0
	==
	setbit
	intc 1 // 1
	frame_dig 1 // inAnyPoolCount: uint64
	intc 0 // 0
	==
	setbit

	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 4
	retsub

// addPoolToNode(validatorId: ValidatorIdType, poolAppId: uint64, nodeNum: uint64): void
addPoolToNode:
	proto 3 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1342
	// nodePoolAssignments = clone(this.validatorList(validatorId).value.nodePoolAssignments)
	intc 16 //  headOffset
	intc 22 // 192
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 0 // nodePoolAssignments: ((uint64[3])[8])

	// examples/reti/validatorRegistry.algo.ts:1343
	// maxPoolsPerNodeForThisValidator = this.validatorList(validatorId).value.config.poolsPerNode as uint64
	pushint 225
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 1 // maxPoolsPerNodeForThisValidator: uint64

	// examples/reti/validatorRegistry.algo.ts:1345
	// assert(nodeNum >= 1 && nodeNum <= MAX_NODES, 'node number not in valid range')
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	>=
	dup
	bz *skip_and9
	frame_dig -3 // nodeNum: uint64
	intc 2 // 8
	<=
	&&

*skip_and9:
	// node number not in valid range
	assert

	// examples/reti/validatorRegistry.algo.ts:1347
	// for (let i = 0; i < maxPoolsPerNodeForThisValidator; i += 1)
	intc 0 // 0
	frame_bury 2 // i: uint64

*for_9:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i < maxPoolsPerNodeForThisValidator
	frame_dig 2 // i: uint64
	frame_dig 1 // maxPoolsPerNodeForThisValidator: uint64
	<
	bz *for_9_end

	// *if42_condition
	// examples/reti/validatorRegistry.algo.ts:1348
	// nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] === 0
	frame_dig 0 // nodePoolAssignments: ((uint64[3])[8])
	intc 0 // 0
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	intc 2 // 8
	extract3
	btoi
	intc 0 // 0
	==
	bz *if42_end

	// *if42_consequent
	// examples/reti/validatorRegistry.algo.ts:1350
	// this.validatorList(validatorId).value.nodePoolAssignments.nodes[nodeNum - 1].poolAppIds[i] = poolAppId
	intc 16 // 900
	frame_dig -3 // nodeNum: uint64
	intc 1 // 1
	-
	intc 3 // 24
	* // acc * typeLength
	+
	intc 0 // 0
	+
	frame_dig 2 // i: uint64
	intc 2 // 8
	* // acc * typeLength
	+
	frame_dig -2 // poolAppId: uint64
	itob
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_replace

	// examples/reti/validatorRegistry.algo.ts:1351
	// return;
	retsub

*if42_end:

*for_9_continue:
	// examples/reti/validatorRegistry.algo.ts:1347
	// i += 1
	frame_dig 2 // i: uint64
	intc 1 // 1
	+
	frame_bury 2 // i: uint64
	b *for_9

*for_9_end:
	// no available space in specified node for this pool
	err
	retsub

// doesStakerMeetGating(validatorId: ValidatorIdType, valueToVerify: uint64): void
//
// Checks if a staker meets the gating requirements specified by the validator.
//
// @param {ValidatorIdType} validatorId - The id of the validator.
// @param {uint64} valueToVerify - The value to verify against the gating requirements.
// @returns {void} or asserts if requirements not met.
doesStakerMeetGating:
	proto 2 0

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 8

	// examples/reti/validatorRegistry.algo.ts:1365
	// type = this.validatorList(validatorId).value.config.entryGatingType
	intc 35 // 80
	intc 1 // 1
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 0 // type: uint8

	// *if43_condition
	// examples/reti/validatorRegistry.algo.ts:1366
	// type === GATING_TYPE_NONE
	frame_dig 0 // type: uint8
	intc 0 // 0
	==
	bz *if43_end

	// *if43_consequent
	// examples/reti/validatorRegistry.algo.ts:1367
	// return;
	retsub

*if43_end:
	// examples/reti/validatorRegistry.algo.ts:1369
	// staker = this.txn.sender
	txn Sender
	frame_bury 1 // staker: address

	// examples/reti/validatorRegistry.algo.ts:1370
	// config = clone(this.validatorList(validatorId).value.config)
	intc 0 // 0
	intc 8 // 242
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	frame_bury 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)

	// *if44_condition
	// examples/reti/validatorRegistry.algo.ts:1374
	// type === GATING_TYPE_ASSETS_CREATED_BY ||
	//       type === GATING_TYPE_ASSET_ID ||
	//       type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	dup
	bnz *skip_or4
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	||

*skip_or4:
	dup
	bnz *skip_or5
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	||

*skip_or5:
	bz *if44_end

	// *if44_consequent
	// examples/reti/validatorRegistry.algo.ts:1378
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1379
	// balRequired = this.validatorList(validatorId).value.config.gatingAssetMinBalance
	intc 36 // 145
	intc 2 // 8
	bytec 0 //  "v"
	frame_dig -1 // validatorId: ValidatorIdType
	itob
	concat
	cover 2
	box_extract
	btoi
	frame_bury 3 // balRequired: uint64

	// *if45_condition
	// examples/reti/validatorRegistry.algo.ts:1380
	// balRequired === 0
	frame_dig 3 // balRequired: uint64
	intc 0 // 0
	==
	bz *if45_end

	// *if45_consequent
	// examples/reti/validatorRegistry.algo.ts:1381
	// balRequired = 1
	intc 1 // 1
	frame_bury 3 // balRequired: uint64

*if45_end:
	// examples/reti/validatorRegistry.algo.ts:1383
	// assert(
	//         staker.assetBalance(AssetID.fromUint64(valueToVerify)) >= balRequired,
	//         'must have required minimum balance of validator defined token to add stake'
	//       )
	frame_dig 1 // staker: address
	frame_dig -2 // valueToVerify: uint64
	asset_holding_get AssetBalance
	pop
	frame_dig 3 // balRequired: uint64
	>=

	// must have required minimum balance of validator defined token to add stake
	assert

*if44_end:
	// *if46_condition
	// examples/reti/validatorRegistry.algo.ts:1388
	// type === GATING_TYPE_ASSETS_CREATED_BY
	frame_dig 0 // type: uint8
	intc 1 // 1
	==
	bz *if46_end

	// *if46_consequent
	// examples/reti/validatorRegistry.algo.ts:1389
	// assert(
	//         AssetID.fromUint64(valueToVerify).creator === config.entryGatingAddress,
	//         'specified asset must be created by creator that the validator defined as a requirement to stake'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 81 32
	==

	// specified asset must be created by creator that the validator defined as a requirement to stake
	assert

*if46_end:
	// *if47_condition
	// examples/reti/validatorRegistry.algo.ts:1394
	// type === GATING_TYPE_ASSET_ID
	frame_dig 0 // type: uint8
	intc 10 // 2
	==
	bz *if47_end

	// *if47_consequent
	// examples/reti/validatorRegistry.algo.ts:1395
	// assert(valueToVerify !== 0)
	frame_dig -2 // valueToVerify: uint64
	intc 0 // 0
	!=
	assert

	// examples/reti/validatorRegistry.algo.ts:1396
	// found = false
	intc 0 // 0
	frame_bury 4 // found: bool

	// examples/reti/validatorRegistry.algo.ts:1397
	// config.entryGatingAssets
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 32
	dup
	frame_bury 5 // copy of the array we are iterating over
	extract 0 8
	btoi
	frame_bury 6 // assetId: uint64
	intc 0 // 0
	frame_bury 7 // the offset we are extracting the next element from

*forOf_0:
	// *if48_condition
	// examples/reti/validatorRegistry.algo.ts:1398
	// valueToVerify === assetId
	frame_dig -2 // valueToVerify: uint64
	frame_dig 6 // assetId: uint64
	==
	bz *if48_end

	// *if48_consequent
	// examples/reti/validatorRegistry.algo.ts:1399
	// found = true
	intc 1 // 1
	frame_bury 4 // found: bool
	b *forOf_0_end

*if48_end:

*forOf_0_continue:
	// increment offset and loop if not out of bounds
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	+
	dup
	intc 4 //  offset of last element
	<
	bz *forOf_0_end
	frame_bury 7 // the offset we are extracting the next element from
	frame_dig 5 // copy of the array we are iterating over
	frame_dig 7 // the offset we are extracting the next element from
	intc 2 // 8
	extract
	btoi
	frame_bury 6 // assetId: uint64
	b *forOf_0

*forOf_0_end:
	// examples/reti/validatorRegistry.algo.ts:1403
	// assert(found, 'specified asset must be identical to the asset id defined as a requirement to stake')
	frame_dig 4 // found: bool

	// specified asset must be identical to the asset id defined as a requirement to stake
	assert

*if47_end:
	// *if49_condition
	// examples/reti/validatorRegistry.algo.ts:1405
	// type === GATING_TYPE_CREATED_BY_NFD_ADDRESSES
	frame_dig 0 // type: uint8
	intc 9 // 3
	==
	bz *if49_end

	// *if49_consequent
	// examples/reti/validatorRegistry.algo.ts:1408
	// assert(
	//         this.isAddressInNFDCAAlgoList(config.entryGatingAssets[0], AssetID.fromUint64(valueToVerify).creator),
	//         'specified asset must be created by creator that is one of the linked addresses in an nfd'
	//       )
	frame_dig -2 // valueToVerify: uint64
	asset_params_get AssetCreator
	pop
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	callsub isAddressInNFDCAAlgoList

	// specified asset must be created by creator that is one of the linked addresses in an nfd
	assert

*if49_end:
	// *if50_condition
	// examples/reti/validatorRegistry.algo.ts:1413
	// type === GATING_TYPE_SEGMENT_OF_NFD
	frame_dig 0 // type: uint8
	intc 20 // 4
	==
	bz *if50_end

	// *if50_consequent
	// examples/reti/validatorRegistry.algo.ts:1415
	// userOfferedNFDAppID = valueToVerify
	frame_dig -2 // valueToVerify: uint64
	frame_bury 8 // userOfferedNFDAppID: uint64

	// examples/reti/validatorRegistry.algo.ts:1416
	// assert(this.isNFDAppIDValid(userOfferedNFDAppID), 'provided NFD must be valid')
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isNFDAppIDValid

	// provided NFD must be valid
	assert

	// examples/reti/validatorRegistry.algo.ts:1419
	// assert(
	//         rawBytes(AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a') as Address) === rawBytes(staker) ||
	//           this.isAddressInNFDCAAlgoList(userOfferedNFDAppID, staker),
	//         "provided nfd for entry isn't owned or linked to the staker"
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	bytec 9 //  "i.owner.a"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.owner.a')
	assert
	frame_dig 1 // staker: address
	==
	dup
	bnz *skip_or6
	frame_dig 1 // staker: address
	frame_dig 8 // userOfferedNFDAppID: uint64
	callsub isAddressInNFDCAAlgoList
	||

*skip_or6:
	// provided nfd for entry isn't owned or linked to the staker
	assert

	// examples/reti/validatorRegistry.algo.ts:1426
	// assert(
	//         btoi(AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID') as bytes) ===
	//           config.entryGatingAssets[0],
	//         'specified nfd must be a segment of the nfd the validator specified as a requirement'
	//       )
	frame_dig 8 // userOfferedNFDAppID: uint64
	pushbytes 0x692e706172656e744170704944 // "i.parentAppID"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(userOfferedNFDAppID).globalState('i.parentAppID')
	assert
	btoi
	frame_dig 2 // config: (uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)
	extract 113 8
	btoi
	==

	// specified nfd must be a segment of the nfd the validator specified as a requirement
	assert

*if50_end:
	retsub

// isNFDAppIDValid(nfdAppID: uint64): boolean
//
// Checks if the given NFD App id is valid.  Using only the App id there's no validation against the name (ie: that nfd X is name Y)
// So it's assumed for the caller, the app id alone is fine.  The name is fetched from the specified app id and the two
// together are used for validity check call to the nfd registry.
//
// @param {uint64} nfdAppID - The NFD App id to verify.
//
// @returns {boolean} - Returns true if the NFD App id is valid, otherwise false.
isNFDAppIDValid:
	proto 1 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1445
	// userOfferedNFDName = AppID.fromUint64(nfdAppID).globalState('i.name') as string
	frame_dig -1 // nfdAppID: uint64
	pushbytes 0x692e6e616d65 // "i.name"
	app_global_get_ex

	// global state value does not exist: AppID.fromUint64(nfdAppID).globalState('i.name')
	assert
	frame_bury 0 // userOfferedNFDName: string

	// examples/reti/validatorRegistry.algo.ts:1447
	// sendAppCall({
	//       applicationID: AppID.fromUint64(this.nfdRegistryAppId),
	//       applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)],
	//       applications: [AppID.fromUint64(nfdAppID)],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1448
	// applicationID: AppID.fromUint64(this.nfdRegistryAppId)
	intc 19 // TMPL_nfdRegistryAppId
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1449
	// applicationArgs: ['is_valid_nfd_appid', userOfferedNFDName, itob(nfdAppID)]
	bytec 13 //  "is_valid_nfd_appid"
	itxn_field ApplicationArgs
	frame_dig 0 // userOfferedNFDName: string
	itxn_field ApplicationArgs
	frame_dig -1 // nfdAppID: uint64
	itob
	itxn_field ApplicationArgs

	// examples/reti/validatorRegistry.algo.ts:1450
	// applications: [AppID.fromUint64(nfdAppID)]
	frame_dig -1 // nfdAppID: uint64
	itxn_field Applications

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1452
	// return btoi(this.itxn.lastLog) === 1;
	itxn LastLog
	btoi
	intc 1 // 1
	==

	// set the subroutine return value
	frame_bury 0
	retsub

// isAddressInNFDCAAlgoList(nfdAppID: uint64, addrToFind: Address): boolean
//
// Checks if the specified address is present in an NFDs list of verified addresses.
// The NFD is assumed to have already been validated as official.
//
// @param {uint64} nfdAppID - The NFD application id.
// @param {Address} addrToFind - The address to find in the v.caAlgo.0.as property
// @return {boolean} - `true` if the address is present, `false` otherwise.
isAddressInNFDCAAlgoList:
	proto 2 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x
	dupn 2

	// examples/reti/validatorRegistry.algo.ts:1464
	// sendAppCall({
	//       applicationID: AppID.fromUint64(nfdAppID),
	//       applicationArgs: ['read_property', 'v.caAlgo.0.as'],
	//     })
	itxn_begin
	intc 7 //  appl
	itxn_field TypeEnum

	// examples/reti/validatorRegistry.algo.ts:1465
	// applicationID: AppID.fromUint64(nfdAppID)
	frame_dig -1 // nfdAppID: uint64
	itxn_field ApplicationID

	// examples/reti/validatorRegistry.algo.ts:1466
	// applicationArgs: ['read_property', 'v.caAlgo.0.as']
	pushbytes 0x726561645f70726f7065727479 // "read_property"
	itxn_field ApplicationArgs
	pushbytes 0x762e6361416c676f2e302e6173 // "v.caAlgo.0.as"
	itxn_field ApplicationArgs

	// Fee field not set, defaulting to 0
	intc 0 // 0
	itxn_field Fee

	// Submit inner transaction
	itxn_submit

	// examples/reti/validatorRegistry.algo.ts:1468
	// caAlgoData = this.itxn.lastLog
	itxn LastLog
	frame_bury 0 // caAlgoData: byte[]

	// examples/reti/validatorRegistry.algo.ts:1469
	// for (let i = 0; i < caAlgoData.length; i += 32)
	intc 0 // 0
	frame_bury 1 // i: uint64

*for_10:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i < caAlgoData.length
	frame_dig 1 // i: uint64
	frame_dig 0 // caAlgoData: byte[]
	len
	<
	bz *for_10_end

	// examples/reti/validatorRegistry.algo.ts:1470
	// addr = extract3(caAlgoData, i, 32)
	frame_dig 0 // caAlgoData: byte[]
	frame_dig 1 // i: uint64
	intc 4 // 32
	extract3
	frame_bury 2 // addr: byte[]

	// *if51_condition
	// examples/reti/validatorRegistry.algo.ts:1471
	// addr !== rawBytes(globals.zeroAddress) && addr === rawBytes(addrToFind)
	frame_dig 2 // addr: byte[]
	global ZeroAddress
	!=
	dup
	bz *skip_and10
	frame_dig 2 // addr: byte[]
	frame_dig -2 // addrToFind: Address
	==
	&&

*skip_and10:
	bz *if51_end

	// *if51_consequent
	// examples/reti/validatorRegistry.algo.ts:1472
	// return true;
	intc 1 // 1
	b *isAddressInNFDCAAlgoList*return

*if51_end:

*for_10_continue:
	// examples/reti/validatorRegistry.algo.ts:1469
	// i += 32
	frame_dig 1 // i: uint64
	intc 4 // 32
	+
	frame_bury 1 // i: uint64
	b *for_10

*for_10_end:
	// examples/reti/validatorRegistry.algo.ts:1475
	// return false;
	intc 0 // 0

*isAddressInNFDCAAlgoList*return:
	// set the subroutine return value
	frame_bury 0

	// pop all local variables from the stack
	popn 2
	retsub

// algoSaturationLevel(): uint64
//
// Returns the maximum allowed stake per validator based on a percentage of all current online stake before
// the validator is considered saturated - where rewards are diminished.
// NOTE: this function is defined twice - here and in staking pool contract.  Both must be identical.
algoSaturationLevel:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1484
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1486
	// return wideRatio([online, MAX_VALIDATOR_SOFT_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 100
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAllowedStake(): uint64
//
// Returns the MAXIMUM allowed stake per validator based on a percentage of all current online stake.
// Adding stake is completely blocked at this amount.
maxAllowedStake:
	proto 0 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1494
	// online = this.getCurrentOnlineStake()
	callsub getCurrentOnlineStake
	frame_bury 0 // online: uint64

	// examples/reti/validatorRegistry.algo.ts:1496
	// return wideRatio([online, MAX_VALIDATOR_HARD_PCT_OF_ONLINE_1DECIMAL], [1000]);
	frame_dig 0 // online: uint64
	pushint 150
	mulw
	intc 0 // 0
	intc 31 // 1000
	divmodw
	pop
	pop
	swap
	!

	// wideRatio failed
	assert

	// set the subroutine return value
	frame_bury 0
	retsub

// maxAlgoAllowedPerPool(): uint64
//
// Returns the MAXIMUM allowed stake per pool and still receive incentives - we'll treat this as the 'max per pool'
maxAlgoAllowedPerPool:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1504
	// return 70_000_000_000_000;
	pushint 70_000_000_000_000
	retsub

// getCurrentOnlineStake(): uint64
getCurrentOnlineStake:
	proto 0 1

	// examples/reti/validatorRegistry.algo.ts:1509
	// return 2_000_000_000_000_000;
	pushint 2_000_000_000_000_000
	retsub

// minBalanceForAccount(contracts: uint64, extraPages: uint64, assets: uint64, localInts: uint64, localBytes: uint64, globalInts: uint64, globalBytes: uint64): uint64
minBalanceForAccount:
	proto 7 1

	// Push empty bytes after the frame pointer to reserve space for local variables
	bytec 1 // 0x

	// examples/reti/validatorRegistry.algo.ts:1521
	// minBal = ALGORAND_ACCOUNT_MIN_BALANCE
	intc 15 // 100000
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1522
	// minBal += contracts * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -1 // contracts: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1523
	// minBal += extraPages * APPLICATION_BASE_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -2 // extraPages: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1524
	// minBal += assets * ASSET_HOLDING_FEE
	frame_dig 0 // minBal: uint64
	frame_dig -3 // assets: uint64
	intc 15 // 100000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1525
	// minBal += localInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -4 // localInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1526
	// minBal += globalInts * SSC_VALUE_UINT
	frame_dig 0 // minBal: uint64
	frame_dig -6 // globalInts: uint64
	intc 32 // 28500
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1527
	// minBal += localBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -5 // localBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1528
	// minBal += globalBytes * SSC_VALUE_BYTES
	frame_dig 0 // minBal: uint64
	frame_dig -7 // globalBytes: uint64
	intc 33 // 50000
	*
	+
	frame_bury 0 // minBal: uint64

	// examples/reti/validatorRegistry.algo.ts:1529
	// return minBal;
	frame_dig 0 // minBal: uint64

	// set the subroutine return value
	frame_bury 0
	retsub

// costForBoxStorage(totalNumBytes: uint64): uint64
costForBoxStorage:
	proto 1 1

	// examples/reti/validatorRegistry.algo.ts:1536
	// return SCBOX_PERBOX + totalNumBytes * SCBOX_PERBYTE;
	pushint 2500
	frame_dig -1 // totalNumBytes: uint64
	pushint 400
	*
	+
	retsub

*create_NoOp:
	pushbytes 0xb8447b36 // method "createApplication()void"
	txna ApplicationArgs 0
	match *abi_route_createApplication

	// this contract does not implement the given ABI method for create NoOp
	err

*call_NoOp:
	pushbytes 0x1b5e82c6 // method "initStakingContract(uint64)void"
	pushbytes 0x79472d83 // method "loadStakingContractData(uint64,byte[])void"
	pushbytes 0x5f7acfd9 // method "finalizeStakingContract()void"
	pushbytes 0x3172ca9d // method "gas()void"
	pushbytes 0x8a87142d // method "getMbrAmounts()(uint64,uint64,uint64,uint64)"
	pushbytes 0xd1366cc3 // method "getProtocolConstraints()(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)"
	pushbytes 0x3b045c5c // method "getNumValidators()uint64"
	pushbytes 0x75aff61d // method "getValidatorConfig(uint64)(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64)"
	pushbytes 0x1f2f0109 // method "getValidatorState(uint64)(uint16,uint64,uint64,uint64)"
	pushbytes 0x2fa22c4b // method "getValidatorOwnerAndManager(uint64)(address,address)"
	pushbytes 0x910e94ac // method "getPools(uint64)(uint64,uint16,uint64)[]"
	pushbytes 0x572767d1 // method "getPoolAppId(uint64,uint64)uint64"
	pushbytes 0x9b504aaf // method "getPoolInfo((uint64,uint64,uint64))(uint64,uint16,uint64)"
	pushbytes 0xfbc63178 // method "getCurMaxStakePerPool(uint64)uint64"
	pushbytes 0x24498cf4 // method "doesStakerNeedToPayMBR(address)bool"
	pushbytes 0xf846dd7a // method "getStakedPoolsForAccount(address)(uint64,uint64,uint64)[]"
	pushbytes 0x83050501 // method "getTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x7bbb6c8d // method "getNodePoolAssignments(uint64)((uint64[3])[8])"
	pushbytes 0xf839414a // method "getNFDRegistryID()uint64"
	pushbytes 0x0c317cfb // method "addValidator(pay,string,(uint64,address,address,uint64,uint8,address,uint64[4],uint64,uint64,uint64,uint32,uint32,address,uint64,uint64,uint8,uint64,uint64))uint64"
	pushbytes 0x3e288972 // method "changeValidatorManager(uint64,address)void"
	pushbytes 0xdd5faada // method "changeValidatorSunsetInfo(uint64,uint64,uint64)void"
	pushbytes 0x18aac7a7 // method "changeValidatorNFD(uint64,uint64,string)void"
	pushbytes 0xf99ef54d // method "changeValidatorCommissionAddress(uint64,address)void"
	pushbytes 0x10809d4d // method "changeValidatorRewardInfo(uint64,uint8,address,uint64[4],uint64,uint64)void"
	pushbytes 0xe778dd5a // method "addPool(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0xbf5259d0 // method "addStake(pay,uint64,uint64)(uint64,uint64,uint64)"
	pushbytes 0x4df8d86e // method "setTokenPayoutRatio(uint64)(uint64[24],uint64)"
	pushbytes 0x418fcefc // method "stakeUpdatedViaRewards((uint64,uint64,uint64),uint64,uint64,uint64,uint64)void"
	pushbytes 0xa2dc51b5 // method "stakeRemoved((uint64,uint64,uint64),address,uint64,uint64,bool)void"
	pushbytes 0x2873f504 // method "findPoolForStaker(uint64,address,uint64)((uint64,uint64,uint64),bool,bool)"
	pushbytes 0x0547f4fe // method "movePoolToNode(uint64,uint64,uint64)void"
	pushbytes 0xcb668358 // method "emptyTokenRewards(uint64,address)uint64"
	txna ApplicationArgs 0
	match *abi_route_initStakingContract *abi_route_loadStakingContractData *abi_route_finalizeStakingContract *abi_route_gas *abi_route_getMbrAmounts *abi_route_getProtocolConstraints *abi_route_getNumValidators *abi_route_getValidatorConfig *abi_route_getValidatorState *abi_route_getValidatorOwnerAndManager *abi_route_getPools *abi_route_getPoolAppId *abi_route_getPoolInfo *abi_route_getCurMaxStakePerPool *abi_route_doesStakerNeedToPayMBR *abi_route_getStakedPoolsForAccount *abi_route_getTokenPayoutRatio *abi_route_getNodePoolAssignments *abi_route_getNFDRegistryID *abi_route_addValidator *abi_route_changeValidatorManager *abi_route_changeValidatorSunsetInfo *abi_route_changeValidatorNFD *abi_route_changeValidatorCommissionAddress *abi_route_changeValidatorRewardInfo *abi_route_addPool *abi_route_addStake *abi_route_setTokenPayoutRatio *abi_route_stakeUpdatedViaRewards *abi_route_stakeRemoved *abi_route_findPoolForStaker *abi_route_movePoolToNode *abi_route_emptyTokenRewards

	// this contract does not implement the given ABI method for call NoOp
	err

*call_UpdateApplication:
	pushbytes 0x46f76533 // method "updateApplication()void"
	txna ApplicationArgs 0
	match *abi_route_updateApplication

	// this contract does not implement the given ABI method for call UpdateApplication
	err", "clear": "I3ByYWdtYSB2ZXJzaW9uIDEw" }, "templateVariables": { diff --git a/examples/tuple_in_box/app.algo.ts b/examples/tuple_in_box/app.algo.ts index fdcb4a41f..206dd2f5d 100644 --- a/examples/tuple_in_box/app.algo.ts +++ b/examples/tuple_in_box/app.algo.ts @@ -11,7 +11,7 @@ class ContactsApp extends Contract { setMyContact(name: string, company: string): void { const contact: Contact = { name: name, company: company }; - this.myContact.value = clone(contact); + this.myContact.value = contact; this.contacts(this.txn.sender).value = contact; } diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 010bfc720..e38f23f3b 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -1,8 +1,32 @@ /* eslint-disable no-console */ import * as ts from 'ts-morph'; +import path from 'path'; import { getExpressionChain } from './utils'; +const LIB_DIR = path.normalize(__dirname); +const TYPES_DIR = path.normalize(path.join(__dirname, '..', '..', 'types')); + +const AVM_OBJECT_TYPES = ['Address', 'AppID', 'AssetID', 'ECDSAPubKey', 'Txn[]']; + +function isArrayOrObject(node: ts.Node) { + const type = node.getType(); + const typeText = type.getText(); + + if (AVM_OBJECT_TYPES.includes(typeText)) return false; + + return type.isArray() || type.isObject(); +} + +function throwError(mutation: ts.Node, access: ts.Node, strPath: string) { + const mutationLine = getNodeLines(mutation, strPath); + const accessLine = getNodeLines(access, strPath); + + throw Error( + `Attempted to access "${access.getText()}" which is or contains an object that was mutated.\nMutation: ${mutationLine}\nAccessed: ${accessLine}` + ); +} + function includesNode(haystack: ts.Node, needle: ts.Node): boolean { if (haystack.getText() === needle.getText()) return true; if (haystack.isKind(ts.SyntaxKind.ArrayLiteralExpression)) { @@ -88,6 +112,36 @@ function referencesInArrayLiterals(node: ts.Node, methodBody: ts.Node) { return nodes; } +function isFromCompiler(node: ts.Node): boolean { + return ( + node + .getType() + .getSymbol() + ?.getDeclarations() + .some((m) => { + const declPath = path.normalize(m.getSourceFile().getFilePath()); + return declPath.includes(LIB_DIR) || declPath.includes(TYPES_DIR); + }) || false + ); +} + +function mutationByFunction(node: ts.Node, methodBody: ts.Node) { + const args: ts.Node[] = []; + + methodBody.getDescendantsOfKind(ts.SyntaxKind.CallExpression).forEach((call) => { + if (call.getExpression().getText() === 'clone') return; + if (isFromCompiler(call.getExpression())) return; + call.getArguments().forEach((arg) => { + if (!isArrayOrObject(arg)) return; + if (includesNode(arg, node)) { + args.push(arg); + } + }); + }); + + return args; +} + function mutationByAssignment(node: ts.Node, methodBody: ts.Node) { const mutations: ts.Node[] = []; @@ -111,6 +165,7 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { if (!methodBody) return; const variables = methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration); variables.forEach((variable) => { + if (!isArrayOrObject(variable)) return; const aliases = getAliases(variable.getNameNode(), methodBody); const refs: ts.Node[] = []; @@ -133,7 +188,19 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { staleRefs.forEach((r) => { methodBody.getDescendantsOfKind(r.getKind()).forEach((d) => { - if (d.getPos() >= m.getPos() && d.getText() === r.getText()) throw Error(getNodeLines(d, pathStr)); + if (d.getPos() >= m.getPos() && d.getText() === r.getText()) throwError(m, d, pathStr); + }); + }); + }); + + const functionMutations = mutationByFunction(ref, methodBody); + functionMutations.forEach((m) => { + // All non-alias references that came before the mutation are now stale + const staleRefs = [...aliases, ...refs].filter((r) => r.getPos() < m.getPos()); + + staleRefs.forEach((r) => { + methodBody.getDescendantsOfKind(r.getKind()).forEach((d) => { + if (d.getPos() > m.getPos() && d.getText() === r.getText()) throwError(m, d, pathStr); }); }); }); diff --git a/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts new file mode 100644 index 000000000..afcef8d28 --- /dev/null +++ b/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts @@ -0,0 +1,17 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayWithFnMutation extends Contract { + someFun(arg: uint64[]) {} + + test(): void { + const val: uint64[] = [1, 2, 3]; + const alias = val; + const arrWithVal: uint64[][] = [val]; + + assert(arrWithVal[0][1] === 2); // Works because nothing has been made stale yet (no mutations) + + this.someFun(alias); // Invalidate all references + + assert(arrWithVal[0][2] === 3); // Error because now all references are stale + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 17a493087..53bf74cb4 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -37,4 +37,5 @@ describe('Reference Compile Errors', () => { compilerErrorTest('ObjWithAliasMutation', 'assert(objWithVal.bar.foo === 7331)'); compilerErrorTest('ObjWithRefMutation', 'assert(val.foo === 7331)'); compilerErrorTest('ObjWithNestedRefMutation', 'assert(val.foo === 7331)'); + compilerErrorTest('ArrayWithFnMutation', 'assert(arrWithVal[0][2] === 3)'); }); From d1ded98dc369b8f3af1bed6e620b1dbea9c0c74c Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 17:38:26 -0400 Subject: [PATCH 17/29] wip: check array functions (push) --- src/lib/ref_checker2.ts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index e38f23f3b..5abb38f47 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -159,10 +159,29 @@ function isAlias(a: ts.Node, b: ts.Node, methodBody: ts.Node) { return getAliases(a, methodBody).includes(b) || getAliases(b, methodBody).includes(a); } +function checkArrayFunctions(methodBody: ts.Node, pathStr: string) { + methodBody.getDescendantsOfKind(ts.SyntaxKind.CallExpression).forEach((c) => { + const expr = c.getExpression(); + if (expr.isKind(ts.SyntaxKind.PropertyAccessExpression)) { + const propExpr = expr.getExpression(); + if (propExpr.getType().isArray() && expr.getName() === 'push') { + const arg = c.getArguments()[0]; + if (isArrayOrObject(arg)) { + const msg = `Mutable objects must be cloned via "clone" before being pushed into an array: clone(${arg.getText()})`; + throw Error(`${msg}\n${getNodeLines(arg, pathStr)}`); + } + console.debug(propExpr.getText(), propExpr.getType().isArray(), expr.getName()); + } + } + }); +} + export function checkRefs(file: ts.SourceFile, pathStr: string) { file.getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration).forEach((method) => { const methodBody = method.getBody(); if (!methodBody) return; + + checkArrayFunctions(methodBody, pathStr); const variables = methodBody.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration); variables.forEach((variable) => { if (!isArrayOrObject(variable)) return; From a8ee31134ee4fd1b7cfea5503964b925962e553e Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 17:53:17 -0400 Subject: [PATCH 18/29] wip: improve error message --- src/lib/ref_checker2.ts | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 5abb38f47..6eacbca33 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -58,11 +58,20 @@ function includesNode(haystack: ts.Node, needle: ts.Node): boolean { } function getNodeLines(node: ts.Node, pathStr: string) { - const refFullLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1].trim(); - - return `${pathStr}:${node.getStartLineNumber()}:${ - ts.ts.getLineAndCharacterOfPosition(node.getSourceFile().compilerNode, node.getPos()).character - }\n ${refFullLine}`; + console.debug(node.getText()); + const nonTrimmedLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1]; + const refFullLine = nonTrimmedLine.trim(); + const char = ts.ts.getLineAndCharacterOfPosition( + node.getSourceFile().compilerNode, + node.getNonWhitespaceStart() + ).character; + const nodeOffset = char - (nonTrimmedLine.length - refFullLine.length); + + console.debug(node.getPos(), node.getStartLinePos(false)); + + return `${pathStr}:${node.getStartLineNumber()}:${char}\n ${refFullLine}\n ${' '.repeat(nodeOffset)}${'^'.repeat( + node.getText().length + )}`; } function getAliases(node: ts.Node, methodBody: ts.Node) { From 5c5d525468f30675b12a40c58ba572495f2cf1d8 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 20:31:26 -0400 Subject: [PATCH 19/29] wip: even better error messages --- src/lib/ref_checker2.ts | 62 +++++++++++++++++++++++++++-------------- 1 file changed, 41 insertions(+), 21 deletions(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 6eacbca33..6d96d3566 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -1,4 +1,5 @@ /* eslint-disable no-console */ +/* eslint-disable no-use-before-define */ import * as ts from 'ts-morph'; import path from 'path'; @@ -18,13 +19,34 @@ function isArrayOrObject(node: ts.Node) { return type.isArray() || type.isObject(); } -function throwError(mutation: ts.Node, access: ts.Node, strPath: string) { +function throwError( + ref: ts.Node, + aliases: ts.Node[], + mutation: ts.Node, + access: ts.Node, + strPath: string, + mutationType: 'function' | 'assignment' +) { const mutationLine = getNodeLines(mutation, strPath); const accessLine = getNodeLines(access, strPath); - throw Error( - `Attempted to access "${access.getText()}" which is or contains an object that was mutated.\nMutation: ${mutationLine}\nAccessed: ${accessLine}` - ); + if (mutationType === 'assignment') { + const refRhs = ref.getParentIfKind(ts.SyntaxKind.VariableDeclaration)!.getInitializer()!; + + const aliasInRef = refRhs.isKind(ts.SyntaxKind.Identifier) + ? refRhs + : refRhs.getDescendants().find((d) => aliases.map((a) => a.getText()).includes(d.getText()))!; + const staleRefLine = getNodeLines(aliasInRef!, strPath); + throw Error( + `Attempted to access "${access.getText()}" which may have been mutated. You might want to use clone in the initial assignment\nAssignment: ${staleRefLine} Suggestion: clone(${aliasInRef.getText()})\nMutation: ${mutationLine}\nAccessed: ${accessLine}` + ); + } + + if (mutationType === 'function') { + throw Error( + `Attempted to access "${access.getText()}" after it was passed to a function. You probably want to use clone in the function call\nFunction Call: ${mutationLine} Suggestion: clone(${access.getText()})\nAccessed: ${accessLine}` + ); + } } function includesNode(haystack: ts.Node, needle: ts.Node): boolean { @@ -58,7 +80,6 @@ function includesNode(haystack: ts.Node, needle: ts.Node): boolean { } function getNodeLines(node: ts.Node, pathStr: string) { - console.debug(node.getText()); const nonTrimmedLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1]; const refFullLine = nonTrimmedLine.trim(); const char = ts.ts.getLineAndCharacterOfPosition( @@ -67,8 +88,6 @@ function getNodeLines(node: ts.Node, pathStr: string) { ).character; const nodeOffset = char - (nonTrimmedLine.length - refFullLine.length); - console.debug(node.getPos(), node.getStartLinePos(false)); - return `${pathStr}:${node.getStartLineNumber()}:${char}\n ${refFullLine}\n ${' '.repeat(nodeOffset)}${'^'.repeat( node.getText().length )}`; @@ -179,7 +198,6 @@ function checkArrayFunctions(methodBody: ts.Node, pathStr: string) { const msg = `Mutable objects must be cloned via "clone" before being pushed into an array: clone(${arg.getText()})`; throw Error(`${msg}\n${getNodeLines(arg, pathStr)}`); } - console.debug(propExpr.getText(), propExpr.getType().isArray(), expr.getName()); } } }); @@ -205,30 +223,32 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { const mutations: ts.Node[] = []; - [...aliases, ...refs].forEach((ref) => { - const refMutations = mutationByAssignment(ref, methodBody); + [...aliases, ...refs].forEach((originalRef) => { + const refMutations = mutationByAssignment(originalRef, methodBody); - refMutations.forEach((m) => { + refMutations.forEach((mutation) => { // All non-alias references that came before the mutation are now stale const staleRefs = [...aliases, ...refs].filter( - (r) => r !== ref && r.getPos() < m.getPos() && !isAlias(r, ref, methodBody) + (r) => r !== originalRef && r.getPos() < mutation.getPos() && !isAlias(r, originalRef, methodBody) ); - staleRefs.forEach((r) => { - methodBody.getDescendantsOfKind(r.getKind()).forEach((d) => { - if (d.getPos() >= m.getPos() && d.getText() === r.getText()) throwError(m, d, pathStr); + staleRefs.forEach((staleRef) => { + methodBody.getDescendantsOfKind(staleRef.getKind()).forEach((access) => { + if (access.getPos() >= mutation.getPos() && access.getText() === staleRef.getText()) + throwError(originalRef, [...aliases, ...refs], mutation, access, pathStr, 'assignment'); }); }); }); - const functionMutations = mutationByFunction(ref, methodBody); - functionMutations.forEach((m) => { + const functionMutations = mutationByFunction(originalRef, methodBody); + functionMutations.forEach((mutation) => { // All non-alias references that came before the mutation are now stale - const staleRefs = [...aliases, ...refs].filter((r) => r.getPos() < m.getPos()); + const staleRefs = [...aliases, ...refs].filter((r) => r.getPos() < mutation.getPos()); - staleRefs.forEach((r) => { - methodBody.getDescendantsOfKind(r.getKind()).forEach((d) => { - if (d.getPos() > m.getPos() && d.getText() === r.getText()) throwError(m, d, pathStr); + staleRefs.forEach((staleRef) => { + methodBody.getDescendantsOfKind(staleRef.getKind()).forEach((access) => { + if (access.getPos() > mutation.getPos() && access.getText() === staleRef.getText()) + throwError(originalRef, [...aliases, ...refs], mutation, access, pathStr, 'function'); }); }); }); From 910eb9a0ddd046604862279d4cf3709fff68126f Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 20:32:30 -0400 Subject: [PATCH 20/29] wip: allow clone in push --- src/lib/ref_checker2.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 6d96d3566..726074e70 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -194,7 +194,7 @@ function checkArrayFunctions(methodBody: ts.Node, pathStr: string) { const propExpr = expr.getExpression(); if (propExpr.getType().isArray() && expr.getName() === 'push') { const arg = c.getArguments()[0]; - if (isArrayOrObject(arg)) { + if (isArrayOrObject(arg) && !arg.getText().startsWith('clone(')) { const msg = `Mutable objects must be cloned via "clone" before being pushed into an array: clone(${arg.getText()})`; throw Error(`${msg}\n${getNodeLines(arg, pathStr)}`); } From fe4acb8e4079c12bbd711b8cf35d360bc7a39175 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 20:35:05 -0400 Subject: [PATCH 21/29] wip: add suggestion to push error msg --- src/lib/ref_checker2.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 726074e70..3b57c0937 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -195,8 +195,8 @@ function checkArrayFunctions(methodBody: ts.Node, pathStr: string) { if (propExpr.getType().isArray() && expr.getName() === 'push') { const arg = c.getArguments()[0]; if (isArrayOrObject(arg) && !arg.getText().startsWith('clone(')) { - const msg = `Mutable objects must be cloned via "clone" before being pushed into an array: clone(${arg.getText()})`; - throw Error(`${msg}\n${getNodeLines(arg, pathStr)}`); + const msg = `Mutable objects must be cloned via "clone" before being pushed into an array`; + throw Error(`${msg}\n${getNodeLines(arg, pathStr)} Suggestion: clone(${arg.getText()})`); } } } From ba94c159239aba62ed2d7f873ac59b4fed0757b9 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 12 Apr 2025 21:16:05 -0400 Subject: [PATCH 22/29] wip: ArrayAssignmentWithAliasMutation --- src/lib/ref_checker2.ts | 41 ++++++++++++++++--- .../ArrayAssignmentWithAliasMutation.algo.ts | 17 ++++++++ .../ArrayWithAliasMutation.algo.ts | 4 -- tests/references.test.ts | 1 + 4 files changed, 54 insertions(+), 9 deletions(-) create mode 100644 tests/contracts/reference_errors/ArrayAssignmentWithAliasMutation.algo.ts diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 3b57c0937..ef57a56a0 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -21,6 +21,7 @@ function isArrayOrObject(node: ts.Node) { function throwError( ref: ts.Node, + staleRef: ts.Node, aliases: ts.Node[], mutation: ts.Node, access: ts.Node, @@ -31,7 +32,9 @@ function throwError( const accessLine = getNodeLines(access, strPath); if (mutationType === 'assignment') { - const refRhs = ref.getParentIfKind(ts.SyntaxKind.VariableDeclaration)!.getInitializer()!; + const refRhs = + staleRef.getFirstAncestorByKind(ts.SyntaxKind.BinaryExpression)?.getRight() ?? + ref.getParentIfKind(ts.SyntaxKind.VariableDeclaration)?.getInitializer()!; const aliasInRef = refRhs.isKind(ts.SyntaxKind.Identifier) ? refRhs @@ -140,6 +143,29 @@ function referencesInArrayLiterals(node: ts.Node, methodBody: ts.Node) { return nodes; } +function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { + const nodes: ts.Node[] = []; + methodBody.getDescendantsOfKind(ts.SyntaxKind.BinaryExpression).forEach((assignment) => { + if (assignment.getOperatorToken().getText() !== '=') return; + + const rhs = assignment.getRight(); + const lhs = assignment.getLeft(); + + let lhsBase: ts.Node = lhs; + + if (lhs.isKind(ts.SyntaxKind.PropertyAccessExpression) || lhs.isKind(ts.SyntaxKind.ElementAccessExpression)) { + lhsBase = getExpressionChain(lhs).base; + } + + if (!isArrayOrObject(rhs)) return; + if (includesNode(rhs, node)) { + nodes.push(lhsBase); + } + }); + + return nodes; +} + function isFromCompiler(node: ts.Node): boolean { return ( node @@ -217,7 +243,11 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { aliases.forEach((alias) => { refs.push( - ...[...referencesInArrayLiterals(alias, methodBody), ...referencesInObjectLiterals(alias, methodBody)] + ...[ + ...referencesInArrayLiterals(alias, methodBody), + ...referencesInObjectLiterals(alias, methodBody), + ...referencesInAssignment(alias, methodBody), + ] ); }); @@ -234,8 +264,9 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { staleRefs.forEach((staleRef) => { methodBody.getDescendantsOfKind(staleRef.getKind()).forEach((access) => { - if (access.getPos() >= mutation.getPos() && access.getText() === staleRef.getText()) - throwError(originalRef, [...aliases, ...refs], mutation, access, pathStr, 'assignment'); + if (access.getPos() >= mutation.getPos() && access.getText() === staleRef.getText()) { + throwError(originalRef, staleRef, [...aliases, ...refs], mutation, access, pathStr, 'assignment'); + } }); }); }); @@ -248,7 +279,7 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { staleRefs.forEach((staleRef) => { methodBody.getDescendantsOfKind(staleRef.getKind()).forEach((access) => { if (access.getPos() > mutation.getPos() && access.getText() === staleRef.getText()) - throwError(originalRef, [...aliases, ...refs], mutation, access, pathStr, 'function'); + throwError(originalRef, staleRef, [...aliases, ...refs], mutation, access, pathStr, 'function'); }); }); }); diff --git a/tests/contracts/reference_errors/ArrayAssignmentWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ArrayAssignmentWithAliasMutation.algo.ts new file mode 100644 index 000000000..7a774eabf --- /dev/null +++ b/tests/contracts/reference_errors/ArrayAssignmentWithAliasMutation.algo.ts @@ -0,0 +1,17 @@ +import { Contract } from '../../../src/lib/index'; + +export class ArrayAssignmentWithAliasMutation extends Contract { + test(): void { + const val: uint64[] = [1, 2, 3]; + const alias: uint64[] = val; + const arrWithVal: uint64[][] = []; + + arrWithVal[0] = val; + + assert(arrWithVal[0][1] === 2); // Works because nothing has been made stale yet (no mutations) + + alias[0] = 5; // Invalidate other references + + assert(arrWithVal[0][2] === 3); // Error because now arrWithVal is stale + } +} diff --git a/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts index 9a9ee161c..76aa6162e 100644 --- a/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts @@ -5,10 +5,6 @@ export class ArrayWithAliasMutation extends Contract { const val: uint64[] = [1, 2, 3]; const alias = val; const arrWithVal: uint64[][] = [val]; - const arrWithAlias: uint64[][] = [alias]; - const objWithVal: { arr: uint64[] } = { arr: val }; - const objWithAlias: { arr: uint64[] } = { arr: alias }; - assert(arrWithVal[0][1] === 2); // Works because nothing has been made stale yet (no mutations) alias[0] = 5; // Invalidate other references diff --git a/tests/references.test.ts b/tests/references.test.ts index 53bf74cb4..73526e4f0 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -38,4 +38,5 @@ describe('Reference Compile Errors', () => { compilerErrorTest('ObjWithRefMutation', 'assert(val.foo === 7331)'); compilerErrorTest('ObjWithNestedRefMutation', 'assert(val.foo === 7331)'); compilerErrorTest('ArrayWithFnMutation', 'assert(arrWithVal[0][2] === 3)'); + compilerErrorTest('ArrayAssignmentWithAliasMutation', 'assert(arrWithVal[0][2] === 3)'); }); From 9a7408e9b0158f4299be5f92c6bd4049c3bab9c3 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sun, 13 Apr 2025 08:38:18 -0400 Subject: [PATCH 23/29] wip: obj assignment test --- .../ObjAssignmentWithAliasMutation.algo.ts | 16 ++++++++++++++++ tests/references.test.ts | 1 + 2 files changed, 17 insertions(+) create mode 100644 tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts diff --git a/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts new file mode 100644 index 000000000..50ebae876 --- /dev/null +++ b/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts @@ -0,0 +1,16 @@ +import { Contract } from '../../../src/lib/index'; + +export class ObjAssignmentWithAliasMutation extends Contract { + test(): void { + const val: { foo: uint64 } = { foo: 1337 }; + const alias = val; + const objWithVal: { bar: { foo: uint64 } } = { bar: { foo: 123 } }; + objWithVal.bar = val; + + assert(objWithVal.bar.foo === 1337); // Works because nothing has been made stale yet (no mutations) + + alias.foo = 7331; // Invalidate other references + + assert(objWithVal.bar.foo === 7331); // Error because now objWithVal is stale + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index 73526e4f0..e6a0c25df 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -39,4 +39,5 @@ describe('Reference Compile Errors', () => { compilerErrorTest('ObjWithNestedRefMutation', 'assert(val.foo === 7331)'); compilerErrorTest('ArrayWithFnMutation', 'assert(arrWithVal[0][2] === 3)'); compilerErrorTest('ArrayAssignmentWithAliasMutation', 'assert(arrWithVal[0][2] === 3)'); + compilerErrorTest('ObjAssignmentWithAliasMutation', 'assert(objWithVal.bar.foo === 7331)'); }); From c04c3920e2e81e2b2e423bb7f54886f4b1fa7817 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sun, 13 Apr 2025 09:54:10 -0400 Subject: [PATCH 24/29] wip: obj ref within mutation --- src/lib/ref_checker2.ts | 29 +++++++++++++++---- .../ObjRefAndMutation.algo.ts | 19 ++++++++++++ tests/references.test.ts | 1 + 3 files changed, 43 insertions(+), 6 deletions(-) create mode 100644 tests/contracts/reference_errors/ObjRefAndMutation.algo.ts diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index ef57a56a0..74afff0c4 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -34,7 +34,14 @@ function throwError( if (mutationType === 'assignment') { const refRhs = staleRef.getFirstAncestorByKind(ts.SyntaxKind.BinaryExpression)?.getRight() ?? - ref.getParentIfKind(ts.SyntaxKind.VariableDeclaration)?.getInitializer()!; + ref.getFirstAncestorByKind(ts.SyntaxKind.BinaryExpression)?.getRight() ?? + ref.getParentIfKind(ts.SyntaxKind.VariableDeclaration)?.getInitializer(); + + if (refRhs === undefined) { + throw Error( + `Attempted to access "${access.getText()}" which may have been mutated.\nMutation: ${mutationLine}\nAccessed: ${accessLine}` + ); + } const aliasInRef = refRhs.isKind(ts.SyntaxKind.Identifier) ? refRhs @@ -154,7 +161,11 @@ function referencesInAssignment(node: ts.Node, methodBody: ts.Node) { let lhsBase: ts.Node = lhs; if (lhs.isKind(ts.SyntaxKind.PropertyAccessExpression) || lhs.isKind(ts.SyntaxKind.ElementAccessExpression)) { - lhsBase = getExpressionChain(lhs).base; + const chain = getExpressionChain(lhs); + lhsBase = chain.base; + if (lhsBase.getText() === 'this') { + [lhsBase] = chain.chain; + } } if (!isArrayOrObject(rhs)) return; @@ -196,6 +207,7 @@ function mutationByFunction(node: ts.Node, methodBody: ts.Node) { return args; } +// BUG: `this` is getting passed here as node function mutationByAssignment(node: ts.Node, methodBody: ts.Node) { const mutations: ts.Node[] = []; @@ -258,13 +270,18 @@ export function checkRefs(file: ts.SourceFile, pathStr: string) { refMutations.forEach((mutation) => { // All non-alias references that came before the mutation are now stale - const staleRefs = [...aliases, ...refs].filter( - (r) => r !== originalRef && r.getPos() < mutation.getPos() && !isAlias(r, originalRef, methodBody) - ); + const staleRefs = [...aliases, ...refs].filter((r) => { + return ( + r !== originalRef && + r.getPos() < mutation.getPos() && + originalRef.getPos() < mutation.getPos() && + !isAlias(r, originalRef, methodBody) + ); + }); staleRefs.forEach((staleRef) => { methodBody.getDescendantsOfKind(staleRef.getKind()).forEach((access) => { - if (access.getPos() >= mutation.getPos() && access.getText() === staleRef.getText()) { + if (access.getPos() > mutation.getEnd() && access.getText() === staleRef.getText()) { throwError(originalRef, staleRef, [...aliases, ...refs], mutation, access, pathStr, 'assignment'); } }); diff --git a/tests/contracts/reference_errors/ObjRefAndMutation.algo.ts b/tests/contracts/reference_errors/ObjRefAndMutation.algo.ts new file mode 100644 index 000000000..47c0b8e8b --- /dev/null +++ b/tests/contracts/reference_errors/ObjRefAndMutation.algo.ts @@ -0,0 +1,19 @@ +import { Contract } from '../../../src/lib/index'; + +export class ObjRefAndMutation extends Contract { + test(): void { + const i = 0; + const mockThis: { stakers: { value: { balance: uint64 }[] } } = { stakers: { value: [{ balance: 1 }] } }; + + const cmpStaker = clone(mockThis.stakers.value[i]); + // We're just adding more stake to their existing stake within a pool + cmpStaker.balance += 1; + + // Update the box w/ the new data + mockThis.stakers.value[i] = cmpStaker; + + mockThis.stakers.value[2] = { balance: 2 }; + + assert(cmpStaker.balance === 2); + } +} diff --git a/tests/references.test.ts b/tests/references.test.ts index e6a0c25df..6b7bc1df4 100644 --- a/tests/references.test.ts +++ b/tests/references.test.ts @@ -40,4 +40,5 @@ describe('Reference Compile Errors', () => { compilerErrorTest('ArrayWithFnMutation', 'assert(arrWithVal[0][2] === 3)'); compilerErrorTest('ArrayAssignmentWithAliasMutation', 'assert(arrWithVal[0][2] === 3)'); compilerErrorTest('ObjAssignmentWithAliasMutation', 'assert(objWithVal.bar.foo === 7331)'); + compilerErrorTest('ObjRefAndMutation', 'assert(cmpStaker.balance === 2)'); }); From 84ebb496920c5d23e6d111778e78bb1486b7c3f5 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sun, 13 Apr 2025 13:17:32 -0400 Subject: [PATCH 25/29] wip: uncomment bug line --- src/lib/ref_checker2.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 74afff0c4..981973edf 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -207,7 +207,6 @@ function mutationByFunction(node: ts.Node, methodBody: ts.Node) { return args; } -// BUG: `this` is getting passed here as node function mutationByAssignment(node: ts.Node, methodBody: ts.Node) { const mutations: ts.Node[] = []; From 2c58e78fa7201a70a13d691d2fafc06031a7ab42 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Wed, 7 May 2025 10:30:12 -0400 Subject: [PATCH 26/29] wip: swap error message order --- src/lib/ref_checker2.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 981973edf..80b6a8af3 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -48,13 +48,13 @@ function throwError( : refRhs.getDescendants().find((d) => aliases.map((a) => a.getText()).includes(d.getText()))!; const staleRefLine = getNodeLines(aliasInRef!, strPath); throw Error( - `Attempted to access "${access.getText()}" which may have been mutated. You might want to use clone in the initial assignment\nAssignment: ${staleRefLine} Suggestion: clone(${aliasInRef.getText()})\nMutation: ${mutationLine}\nAccessed: ${accessLine}` + `Attempted to access "${access.getText()}" which may have been mutated. You might want to use clone in the initial assignment\nAccessed: ${accessLine}\nMutation: ${mutationLine}\nAssignment: ${staleRefLine} Suggestion: clone(${aliasInRef.getText()})` ); } if (mutationType === 'function') { throw Error( - `Attempted to access "${access.getText()}" after it was passed to a function. You probably want to use clone in the function call\nFunction Call: ${mutationLine} Suggestion: clone(${access.getText()})\nAccessed: ${accessLine}` + `Attempted to access "${access.getText()}" after it was passed to a function. You probably want to use clone in the function call\nAccessed: ${accessLine}\nFunction Call: ${mutationLine} Suggestion: clone(${access.getText()})` ); } } From b7b968813590933473d6447647eb99db63c5acae Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 17 May 2025 07:37:05 -0400 Subject: [PATCH 27/29] wip: improve error formatting --- src/lib/ref_checker2.ts | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 80b6a8af3..844995752 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -48,13 +48,25 @@ function throwError( : refRhs.getDescendants().find((d) => aliases.map((a) => a.getText()).includes(d.getText()))!; const staleRefLine = getNodeLines(aliasInRef!, strPath); throw Error( - `Attempted to access "${access.getText()}" which may have been mutated. You might want to use clone in the initial assignment\nAccessed: ${accessLine}\nMutation: ${mutationLine}\nAssignment: ${staleRefLine} Suggestion: clone(${aliasInRef.getText()})` + `Attempted to access "${access.getText()}" which may have been mutated. You might want to use clone in the initial assignment + +${staleRefLine} Initial assignment here. Suggestion: clone(${aliasInRef.getText()}) + +${mutationLine} Mutation of the value ocurred here. + +${accessLine} Attempted access of the value occured here. +` ); } if (mutationType === 'function') { throw Error( - `Attempted to access "${access.getText()}" after it was passed to a function. You probably want to use clone in the function call\nAccessed: ${accessLine}\nFunction Call: ${mutationLine} Suggestion: clone(${access.getText()})` + `Attempted to access "${access.getText()}" after it was passed to a function. You probably want to use clone in the function call + +Function Call: ${mutationLine} Value passed to function here. Suggestion: clone(${access.getText()}) + +${accessLine} Attempted access to value after passed to function here +` ); } } From f6f80a6d5c365b916dad3d0b671fcfac7222b4d5 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 17 May 2025 07:44:56 -0400 Subject: [PATCH 28/29] wip: move comments above to avoid output in errors --- .../ArrayInObjWithAliasMutation.algo.ts | 9 ++++++--- .../ArrayInObjWithNestedRefMutation.algo.ts | 9 ++++++--- .../reference_errors/ArrayInObjWithRefMutation.algo.ts | 9 ++++++--- .../reference_errors/ArrayWithAliasMutation.algo.ts | 10 +++++++--- .../reference_errors/ArrayWithFnMutation.algo.ts | 9 ++++++--- .../ArrayWithNestedRefMutation.algo.ts | 9 ++++++--- .../ObjAssignmentWithAliasMutation.algo.ts | 9 ++++++--- .../reference_errors/ObjWithAliasMutation.algo.ts | 9 ++++++--- .../reference_errors/ObjWithNestedRefMutation.algo.ts | 9 ++++++--- .../reference_errors/ObjWithRefMutation.algo.ts | 9 ++++++--- 10 files changed, 61 insertions(+), 30 deletions(-) diff --git a/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts index 4bab42f98..53b47a5df 100644 --- a/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayInObjWithAliasMutation.algo.ts @@ -6,10 +6,13 @@ export class ArrayInObjWithAliasMutation extends Contract { const alias = val; const objWithVal: { arr: uint64[] } = { arr: val }; - assert(objWithVal.arr[1] === 2); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(objWithVal.arr[1] === 2); - alias[0] = 5; // Invalidate other references + // Invalidate other references + alias[0] = 5; - assert(objWithVal.arr[2] === 3); // Error because now objWithVal is stale + // Error because now objWithVal is stale + assert(objWithVal.arr[2] === 3); } } diff --git a/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts index f6da82466..1f273c687 100644 --- a/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayInObjWithNestedRefMutation.algo.ts @@ -5,10 +5,13 @@ export class ArrayInObjWithNestedRefMutation extends Contract { const val: uint64[] = [1, 2, 3]; const objWithVal: { foo: uint64[][] } = { foo: [val] }; - assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(val[1] === 2); - objWithVal.foo[0][0] = 4; // Invalidate other references + // Invalidate other references + objWithVal.foo[0][0] = 4; - assert(val[2] === 3); // Error because now arrWithVal is stale + // Error because now objWithVal is stale + assert(val[2] === 3); } } diff --git a/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts index 5adcacc06..cd6879d6b 100644 --- a/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayInObjWithRefMutation.algo.ts @@ -5,10 +5,13 @@ export class ArrayInObjWithRefMutation extends Contract { const val: uint64[] = [1, 2, 3]; const objWithVal: { arr: uint64[] } = { arr: val }; - assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(val[1] === 2); - objWithVal.arr[0] = 5; // Invalidate other references + // Invalidate other references + objWithVal.arr[0] = 5; - assert(val[2] === 3); // Error because now val is stale + // Error because now val is stale + assert(val[2] === 3); } } diff --git a/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts index 76aa6162e..f9cc04c1a 100644 --- a/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayWithAliasMutation.algo.ts @@ -5,10 +5,14 @@ export class ArrayWithAliasMutation extends Contract { const val: uint64[] = [1, 2, 3]; const alias = val; const arrWithVal: uint64[][] = [val]; - assert(arrWithVal[0][1] === 2); // Works because nothing has been made stale yet (no mutations) - alias[0] = 5; // Invalidate other references + // Works because nothing has been made stale yet (no mutations) + assert(arrWithVal[0][1] === 2); - assert(arrWithVal[0][2] === 3); // Error because now arrWithVal is stale + // Invalidate other references + alias[0] = 5; + + // Error because now arrWithVal is stale + assert(arrWithVal[0][2] === 3); } } diff --git a/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts index afcef8d28..c7f96180d 100644 --- a/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayWithFnMutation.algo.ts @@ -8,10 +8,13 @@ export class ArrayWithFnMutation extends Contract { const alias = val; const arrWithVal: uint64[][] = [val]; - assert(arrWithVal[0][1] === 2); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(arrWithVal[0][1] === 2); - this.someFun(alias); // Invalidate all references + // Invalidate all references + this.someFun(alias); - assert(arrWithVal[0][2] === 3); // Error because now all references are stale + // Error because now all references are stale + assert(arrWithVal[0][2] === 3); } } diff --git a/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts b/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts index 4cbc41be8..a98a6169a 100644 --- a/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts +++ b/tests/contracts/reference_errors/ArrayWithNestedRefMutation.algo.ts @@ -5,10 +5,13 @@ export class ArrayWithNestedRefMutation extends Contract { const val: uint64[] = [1, 2, 3]; const arrWithVal: uint64[][][] = [[val]]; - assert(val[1] === 2); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(val[1] === 2); - arrWithVal[0][0][0] = 4; // Invalidate other references + // Invalidate other references + arrWithVal[0][0][0] = 4; - assert(val[2] === 3); // Error because now arrWithVal is stale + // Error because now arrWithVal is stale + assert(val[2] === 3); } } diff --git a/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts index 50ebae876..e65c6bcd9 100644 --- a/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts +++ b/tests/contracts/reference_errors/ObjAssignmentWithAliasMutation.algo.ts @@ -7,10 +7,13 @@ export class ObjAssignmentWithAliasMutation extends Contract { const objWithVal: { bar: { foo: uint64 } } = { bar: { foo: 123 } }; objWithVal.bar = val; - assert(objWithVal.bar.foo === 1337); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(objWithVal.bar.foo === 1337); - alias.foo = 7331; // Invalidate other references + // Invalidate other references + alias.foo = 7331; - assert(objWithVal.bar.foo === 7331); // Error because now objWithVal is stale + // Error because now objWithVal is stale + assert(objWithVal.bar.foo === 7331); } } diff --git a/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts b/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts index ab544e5d4..2f40b21f0 100644 --- a/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts +++ b/tests/contracts/reference_errors/ObjWithAliasMutation.algo.ts @@ -6,10 +6,13 @@ export class ObjWithAliasMutation extends Contract { const alias = val; const objWithVal: { bar: { foo: uint64 } } = { bar: val }; - assert(objWithVal.bar.foo === 1337); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(objWithVal.bar.foo === 1337); - alias.foo = 7331; // Invalidate other references + // Invalidate other references + alias.foo = 7331; - assert(objWithVal.bar.foo === 7331); // Error because now objWithVal is stale + // Error because now objWithVal is stale + assert(objWithVal.bar.foo === 7331); } } diff --git a/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts b/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts index ea895464b..e93a2f1b1 100644 --- a/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts +++ b/tests/contracts/reference_errors/ObjWithNestedRefMutation.algo.ts @@ -5,10 +5,13 @@ export class ObjWithNestedRefMutation extends Contract { const val: { foo: uint64 } = { foo: 1337 }; const objWithVal: { baz: { bar: { foo: uint64 } } } = { baz: { bar: val } }; - assert(val.foo === 1337); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(val.foo === 1337); - objWithVal.baz.bar.foo = 7331; // Invalidate other references + // Invalidate other references + objWithVal.baz.bar.foo = 7331; - assert(val.foo === 7331); // Error because now objWithVal is stale + // Error because now objWithVal is stale + assert(val.foo === 7331); } } diff --git a/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts b/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts index 427ba1ad5..8cf1f3e1f 100644 --- a/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts +++ b/tests/contracts/reference_errors/ObjWithRefMutation.algo.ts @@ -5,10 +5,13 @@ export class ObjWithRefMutation extends Contract { const val: { foo: uint64 } = { foo: 1337 }; const objWithVal: { bar: { foo: uint64 } } = { bar: val }; - assert(val.foo === 1337); // Works because nothing has been made stale yet (no mutations) + // Works because nothing has been made stale yet (no mutations) + assert(val.foo === 1337); - objWithVal.bar.foo = 7331; // Invalidate other references + // Invalidate other references + objWithVal.bar.foo = 7331; - assert(val.foo === 7331); // Error because now objWithVal is stale + // Error because now objWithVal is stale + assert(val.foo === 7331); } } From e2081b9669eb03db7087a033ee469512b5fac723 Mon Sep 17 00:00:00 2001 From: Joe Polny Date: Sat, 17 May 2025 08:06:47 -0400 Subject: [PATCH 29/29] wip: add chalk --- bun.lockb | Bin 280281 -> 281507 bytes package.json | 1 + src/lib/ref_checker2.ts | 62 +++++++++++++++++++++++++++++++++------- 3 files changed, 52 insertions(+), 11 deletions(-) diff --git a/bun.lockb b/bun.lockb index 396111c49ab39a0b98a8336477ff3f3bc67c1550..fe88ac02ba19e1c2e1c8b86cdc2021f4d0e87df1 100755 GIT binary patch delta 49492 zcmeFadwkFJ|NsAbz2?PUl_bZtmO}>?!<@D?^KxcbQp7MB#)g?=jI`-UNIcVn%BfOD z3!PBW`5j3@2a@P)Nku1;`dx3&=i{Zl`}TSN-rwK%`}?og#clV;{rWf`o{#6_^=!|z ze_qvxP1Spv#8=(&!oh*x_aE}x$h}qDG);Rwt=4a6(&oN4zs-kNA6@FS>|3oz1)n|} z7xb$W7`Sf3)Z{??u-xo1qhZ+-Mvlv#FfnJZ-{-r)=PTY=!{<8(J7QwajX7f{O-yxm z2kI1!jq&-aKy$Dm>~FPwzH_nPV$a8311Dqgq#TNx;Pc%O>+@ZR{|BY2w5|9`|5z|U!viq^*D4v5=`+q07+I1AD_H3;0wLdp|V#0_q*(29F$D?W$rP^L5 zV%7Tmy!@Pm;X{3w;aA45gr#A{-U#`8pE3%neCy?2`e(2jrHH?mc-8(YR%5&Yt5&SC z`F1z(MxjkZH-Axa&ctEaW3q?myhem7T#r?+AHk}kyUD2GnS@pM)?exKRl`1j)iiW% z-{=VR0IXRl${5HRMDy&)-KT@hN#@h7Zf0FnmU$*RXS%dwg`>*x?BUBYdaf8lk+2 z1w%(Uw+E|bFKyv9(ZQZW%AJ(ko#XHE66~#cF7_wDM-QVr$PIH+p2k z@Vp7W5vpnOINx@-W`3)4Dp)6FJ-Mpk<&3>CZ|sNyUu1nQv!%|(YNn=Rt73;^`B&V_ z>0Pl-=EziUTC%Wegcs)^q8E<6W~vg zPBW0v$+Hu3vWHDd$eZ{!4b(U+wR~`AuiP|#{cW77B5LLJ`-OD#|O!mZFDl+&QyqVp-2INebP%t4O zXKM8xN`I-Zc$|%h>{x%jW9lol*Gt1|@0y_$; zeXSQ(=`(ElCiwO68&Iysc+^BTD5kDC@hqd_YFM_DqT=LiFXP2nt$`DnUdEZUMtv#F z9y2Cy;w0aUp*|lQdhuwi`g)LbHL%6l%dkU+duwR`z8cmP+Xx$tZGio>zsH}%Hp8EZ zP1L?Mgn(Mw4y(b5#j+U}`>^WKfqtI<4U?sjIGpEARuY?lR!Qn8&yLHRkUc49qHjE_ zN9m%OH1#xcSDeDlQ}?;bW4w+{${#nzN7#4YXs>{w?rqTL`wpmOls&dEKYP-!-28m6 zpxa2No=2u^2My5(d^y&ex*Masg1c1k8t_zsSB|ERYJ4r7@#i+J7eCIcZ40?n+AgfF z#j!L^r9I@ld~Thh+N>J2p}|CN`XX0!FQ!v>fh25gY%!f>qKZGC?A5s!tCc**uGHyR zP5)?X)2DcCTt$1djJD$||ADK$d;>^F{-Wahr+Syb&sY`ExzKBNO-5DC9z?}8u&2qW zg2qqt2B|k(vvSdNucE5f2C$ly;W@)OqWFBn7#w}Nkv;@}vz^!B4{uTfSQf2kc;oU2 zR`%-bnn24Y8JszapTX9mHxXwo{OLkaerq(+sReraqRXSe&0dniEIf zgkSJAq^+=;qR0eS#n;rVYUky5oR=#%X#e4z-gr$a9GAlu@4IW3=TDrJJ!vx6>|4a2 zPp+4+Ds^JcSQ_W^J#GC3PW<_G5+~bIs?PCJ4bK_prW!FJ$K9}VCS{LQuE924U#IZ= zrbR>Md8uE)s*Y!{>hX}fy*Bj2YHl8f%dR1}Mq=oE&(E~>LAdhg=S<2i7(S8B$?Itz zR&AaD18dVZ(BC1O3DqU!{(Jo3o%wt)jh)yvEJNs?3Og6TT|X$7&iUTKfrB&E%dwRx|d2g|%FCMFbS z=a2D~;cHIvMvg6*z}O$g*BnOfBle!?e04$9n637F#eKG57<=eDq*WVMI903G@^^RQ zt2QXw0@HBjv2&=L$oV;Ps~lc1Y|@0hu{q00cM0*gVYPeT@|bs9nTD^mGYYG+hp+b9 z9Xa!@$JeO!CSLt(fmJ!1A9VW>C|>F8u3D=oWsR5Zaj=r#xYirogQeb*OL@W@|f_?W24r4-TD{l)V%@tYGyiC7i~K)o+ASpG@CC_ zfVP!gWY9RT!q;|mx3xFf_@UT~;5k&Rg1)j1$;N7T=uW(BD{Kwy6<9SaZ(_oPoRK+G zYv3zi-o)$)6S9j6eSeTqJ$Uk2Z{ItCUm5=(Rs+1=#;?Gt2X|mqU?EoN`eBu>Jyzvh ziB-d6u}b&(X0Jmbe06Xi4cA1zgssgMSiH=ek>a^nB`CydWem?5I(Z~3b}+s&L{>ys zd{xkLiJ9Q!m5nqe|dM|Wv_dwZ^qVzAEo=UTeo{%d=#tFa^Lh?IvZbI z{*ZK<)Q&s6a__)u><>6qYt$+_^p@9yU8GWN_w4jq+!HJRDy#>}ZRUmrT zXEU4itT|}kQ$uQ>cX_Zmse;bu?m!=b7yy|!-d#FQle4^DhI9Gby$;u}wKl(V6ElK)kwBpmjiamt8k!=>7Z z7@z9$7dv_F!h!0s&YE^@{o|doc3}#QZyyc?FZK%cI~z#W(J5&k_TTB0@$)$+zC$<= z6X%TT(AIyyQ_>+EI>wB5cWX;bO!6l=@g2jV``Fsl0=IzBM|juZRaBosNp-x!>0xSe zv~_~c@vD+TTk+btMQun<3S3;*S<|Vle~?qwDID5XmjfnI72Hw!4bK}T5{6nb%PQaP zRp>UnL3jb@c&jA;VJE&zIB-RMXH=KAp)vJ+zA#a-&heH>q1W*=7|{+54}~uEimc#l zC`byn$7|=57Nq)TIwf7hq0RWMy+W@_@_*;VcMAvNFLOq9YwI83lynORmtN-cb#O|P zQ$vRc4Rw=lXp$6af4SFg=7N?^##0A_sxr6@uZ{8qEAWltDmQmqLT%g>NODs2K08 z>Dkub-zn=E_AhthGs6C#oV<*1@YO5T@BEC^U{oVUN1;$}Lh3t1e^pZOPP{H|iVq33 zaq^p|25WM84RP6xg!;Row+Xd%L-7edUmrKLiqI%GRHX@v#!2YirUHR$T-2;7r)4)Z z^=#-RLf5+N!e;EeZfG2#R3|?nHMEvcSFdL+lKg)-@z;h!sfo-3j1kUA3f+l!_G${f zh^MioBdo((Ty#nq<$9TT>SRTYW^g`U7bl@{YVbWm$xcGcHWgZsz$tB+>c85_>k|&W zfIor^?jQ&1w{*Vl)7C%OiSHW@J7efNeb0V^YTTj@u4g{4FM?|Cxsq3>uECg!nAZ*bV(!6_LW4&6xiG)EQP5nPYwjlAaJOFWGk zW6f?|n+Z|_E4hsrgr~8KbFZ}1PW+H?aBzE{FU3h1lInlSDH#$DRbwfDifg!O`Z)2~ z;oxmBE{4R^(A$J`y}M%@s@~D7i!L(yU7Yx#;m{p0Z@3u!&?`1Yl)DG~=#&i&2L^O< zz8=~(w1##uCB+xIP5TT_sobVo|=A?C$L%L#`r=ep}gjvDR|<>U2o^B+%1j>hThI*eDa5velWE9o{usVXA$ zA|Z_^>%3)B@F%>mMkw?&o113DyEX#cRJ=xM+*{(Q-);x|3!V7faOfkL);5#gHYrr6 zhu1})ZYBOKrz|%dd=l2&NuZ-AoxD8me?7e%-W4_pPYaP9l(BpbPea65UX>IGWH_Tn zwGDO3hzvJtE?A7$(K(iz8v2%yM#sJ60u8TrMvZP8oKNH3p7?t^WuwEPWsHf}PhES5 z@KiqSYn2p?qhdF0a1f#PZvUSp!~*aZe=yLSs-65Mss6T3Nq#sq1z-CC%fD?Bt0{hL zICvV?S$TukUCY=hb#Nu2G$-M%HWdi;aObRxlUES--{zDQghTIMM;3~44;aCiK9S1T z5IWnV;OBT9-A297TxvI1HtCKe|%o(C&VmOpH(AzYK;UZpy*V9Sh z#`FoHRHt-8YA}6}m~PUGoU%#b;4%F6it(2^d6UDGR>IFDr)+XKxN0z`0_WJI)PVm6 z=j%yrgPAudasKGk;QfS#D=PRqp^jpq?nBNtt5Z_&CcLnl_IX0tsv>Y*wp+~FY@ctS z8&z?r&zIw7et?jM(!I-v-otB+=dSADxx@G`QA*_><&+e1>EYWeo>lv^6F)5+oHpF& zyIu|QzvGnPr{(y3Q=HOisllfS6(|(Abc8c%dfVWF5kB8cH|oNXKHqIl{`Az~eT0U& z>=dD)V*Y_n$xY$lHfExqo4rn+bLEV-!MpO@5u4j4ngCamxAa0?MxDJB`Xq&Jv!2i4 zh#7hXPu*dM=JGy?*VUc-@MyafLn{gCvJ5zh9g{-)@wfx(BF#<;)g0s9P}uF+!+Ya3 zbK`UY&cxFNLcZsdD=5m{6HgJ+mG5&GV5@uzcM`g!hNcr@SJN)S{_rB6mNge-LQ=58 zSi3Sp*AU`5U@zAp?*yK%Ax@&JlA{Z}X<}lsll)_xl3T)|EikV#9T869seP5SID?(W zxd)U@ZK4Ty&DJIH0$xj9d7UY6!(^K?UYFWwZqNDV;^E~dXJE|Ra`LDE|Os1NGS9KA+_)v_e@f;kW0<&vu5=g zJdG85UUpLOZoCY4u^k|Eoyrb0ndVkqG%d0iRQ0QPT(4|_(`k{Df1MlfZa#}a_JU(m z{ur+%6)>oLBe?t~Z_8m3b!BzpX|(VdfjM|yca9S3;Uvs$Q(=ZKC*4N*S~Nc#jJ}zo zorL+UO+wrubS_{Hw&Ah)<0TGB3f3xev$Ho2C8Tx4%4WSR#7lC=E2>y~ibifQA-Bh& zwS=0J*8Apg@l5UZ?0msdggBNqOAW0cq*dmA?+NY0)4KA`y0vfdy5es7p=33+gb1(JZ}MvzSSGjkb81mho@O$ZF6Bn-4?l1>oVz$r<&cHVQ4mg{;_ z-MB=P9DTdDyuE|f6ueGE(S4Tp^VXvfzRvvNlr0K}Qtt55b3`M>ay(Vz9dM?j;Z#WrqL&;kj4%N6j@|8qA9F6y9eIXL!SY>i%!>g ztp(o7@^;4?@DxXJc}XD$&rStvX)oT@Zrp~!d;wVK?G#MK{G`w*Ja2Njko^xi@elD$ z1?H{94G*Qd&sf}@Ih5x_y0340&k)3WitZ#;#k@$lmOi@ibjF0LdzjfYoC0iH&J`wE-hx_^uN z3h&Rh)LRlcgR<#`hT-)*Tf^&kO6isPhfV2Cd`~B@BpjM^zqgdU7VX1RPrPrUmptHI z%-#shz*AXx$w~ZPLCG3D=PFyn8GTt~CNzpu|MW&B1&`zLjDQO$Ww|%<)Xrs@hv&^6 zcjVA2>v2cjgohm$;Q*TaDVBR6kLfnK?^lhZKapW`_`O}*NIf_ z#uJ){r&(qv&P@uvjA#2n&8P7+>Xn^D)=dki?1^w_>_gs|u)i{*kK?s=b8GE?dNxj8 z-G{y0-gx!L)2i^EnytZ84`~B4_$8j&z{#LVQsAOToUhln4fTB_GWc4wj+3_`9NG?3 zbu2=L=@091sc~_&TICfIauVAo`6oDePliJ;!PFf($5*QAk9xzya$^bi!MlbyZ~7m> zQ&-)o4t|8!*S*FQA9KEbs%>c5V?JMRqTM+NdMtw-Vx_@0c3;nUJ?%j^Dr+ z({f%D?2==> z560``4MSd1@Lzb>=*SqVxiPZO=u1U^Jgsg9v2}7Zj+bS_de`YjjCY!7w#lpAUH73I z@j7_9nkPr&*diFfAMtD%Tv**UpB*BOE6eb_E@)#ufv1bxoxf1)=ez-;Bznf~qg5(O%yGIB1iJJ&%KD-;_HoU7{PtP@KzThsq4J;`_gW>E|?UF)|;w5`| zbO6P>9*-Gi33uI6{w}cyPZyjU7yJTms5^FDw?_6O7I0_|p1K-xzXu({8;DoM^(MR+ z=^QD8&*BZ#gRoHiOWuVT?cSU2!t+*}F7wy$G^(_g`K$PHWPKdxXwnI<8F4%v%u4c4 za^kmz{cD`OZQ z+$XG|UkE7+n{-A}DDgFKpK>3~hQ{KxCeGbhLXY5ig>%~vevH@OeFoXuDcKPYe)ziP zuXIOhsNcW5M{|7FV+GWD!{=+^mXUZzQm8v#E4*{vt@SQEO^^3~2g!=Zya&yEJ$OZB(iFJ+BW{h3bQ9zC-y*%J<&zsvc0PuozJU0zbwV27m847{#x zg=~HP*PN2Q;Xv(ooUiw`4PF1v*}c6-lK(y@@7-{q#%^cLyKRF@cXMev`Fuy&Pe@(% zhPwJ5Z#WrTF4<@B+PEEMZwnpA^QJ*w{9bR;x%&-Dj>b_!cS{Ja!t3B1d#{afw+Ie} z-;E5L@)zQ@b<0*w8}ZK86#PMPdO{gWe9!BGySs+QtPFc@wxxbYY zzdyC8p-;c4>V3-F0O(4~WhtRs z6!%l!Dj|dJ#?uA&BdY=#6qkox>K>?F-rjNs!2SFut8zL~znhW8>3;r`RgZcgWz29> z|GQO#*+<=YE*$qGTM@BW`l3)KQn~?1p8?eGMr66J&sW|m;b0_tgN>I}K|_)FFr<&H z_y{?C{?4l5xo)gymEIY5pt|$mfoQeEmv1BglU1c-kqR4U)Bl}4pSYV*ZFHYaC#!sm ztzXU-xx=)K2raaSkP<$E^!ZO#=^jP0tC2qCt$MlErJhv>9!IjJmX~T`m2ka{;K1TG z@a6x&LOB?j_4*HB_%5wVWN_ z{gkuy{|e6fs$d(c=&U+e$8F|2Zk*5ecUIN1uesH*gSa2rXmk)M{t!}gK0~@tjv#$x z#lMlmM^@>-wf1}c5`@4Bq>pTr)A!>#?uz^cPmMh(icTYa%3H<%hGfqmeac&v{s&UL z_rtUD{rpgTlpE<;1uOV{&e4xU?$A`UasQ1~S<$x4bF4kj=9jHXe4O?F3+s--|4s&q z_bN~wm+(Uks*A0Ny#g!Vz}kj#_{b{Vm6kWcR>n{E5A!B7&4TXON<{R=>hqthW~&eB zRPgmSeR-<}4T48G`G;${<2=Ns`cGE5MvzWPN80qV3g%jyXSuA>7g%3byV0H2FK3I~ zH9E&e$SOG3`m*ZA-B@*N0aj59_2VyA$g%PF+IU&zGuAI}Yrr4(Gta8v37c`9O(?62 z=P9f%w&$@*x5dVnw?bPjmsP%3tS_sP*oF;ZcViW`M?YjW5pDomlfV({%T~w#&HAz` zSgnw)pw?Kct3HIUq~~C@f@)!_I9Z?8a>jh>ZHEnPj`CJxbEW0w?K$w4mY27xp%q-V zHC9QI`Jr-BAA7 z?QiV>YX=4FBoDS=h_yql9d7LiYjdp~g{?xth1Q>r)#pFi^N7FGrju1iXBFANY#Sk~ zh`X$vW4Ww?^Qh6WU(gIlpAGUsZ zs|r?IE-SwjE40pXSv73E_5aQ)>PddcKCLyN^}oetkW~R&vFgdomdnb2&HA!hOxv(R zZ(9Ftta|t^R^_~B?fY1LWEI@U52gE9Yd{GP*#xq>zJ9R2ta^IV`m#!Y%KGK4HUvMd zR6{H9Lk*0^Dt!p6a?Zyp>jjoqZA?H3Yhd+}jl(v_Dq%~kqLTO#axVYUI~;Tn;`4Vl z20qZ{8jMvbL##gxtL6;H>LaV*NPeh!V=OOkl|J8ctak?#s6)hD8&Te>!n-a1JFD(4 zBwqW`a+^+86|J!T-&r+qRg^Q~s|%f*zKZ^fE^yoRsLd{`;vT~at+8BI)jwhV@>b1W z50`z?#{V}~_utKtaUtM-{?4jF&k?V^;9poZ;9P_F%=|wfxM8Yimj0a$IF-w4aR!SktCga(KiRah z7vfi<*vqkvRlK#j!kSxOHsCBOYv4RyR+nOYLPy&;$5*Cu5`;~#k*TyR`q36uDs|q*TgwI*K#oCv!O8*L$ zf4+a|hqWqiyY*!i+{q7>_qMgW1o`Z$z_qLldjPWU*#z%nRlzosEO4_R;#Cu_5aQ)e_b0dE5E3o4b-<0vMQ*N^<|Z?vGxDXs^?8?{NGtcwcv+F z>ME?#xAD>!xdHX413(pZ^dkPvDnn<>W#xCpYJa=Va#=Neko9F1%;tyE55sE2MqpLX zNJZ)z^a7sMRE)L>$J&GiZbH6G{0FOi6Ny(vlWn^4R(uLv6;HMCvN{y_rV-Ex6x)dM zRy~}ngxI^Sy~o;xSQY4C)wBDoZ*2S$Yag(7skO_oO8*eHNP$%ZRM4X~!D?$k?(@Nh z3h*g!)u8_i&j^d$p8bc1gl@yiKO0m-f=#9faPY78Id=9fHbes6+38D98R!;`?k=6C`&lAFbo)Ge%fBtzws7Hl*M)J=S z!tzfBwN=Rf|N9A{`=1N{mnVc9H&^gCuHEzPVCHl4?i;_j&NbQbd=KDr@Z7zGV`4x??d3s7*#mgSJsZI6br1Xtzx4qJ{d%rFl3hq6`BP_q~ z_bR_*yPEwM`}>($asJ9CEzaM=pKfNy`TP01n@?nVn3PM1K5_}sOD`ch!;}dut^>%Z z1L$Rz)B$v>3pgXt+oab8oD?Xn3%Jgl5?EaikW~-R*Ob%)^sf)7Tp!TSWY*_L^re6; z0+}XsDPWU8{-uC{X0t%YfvJgr zghartrZ5rEusPtM!0jf!Ibff_yyk#A&3=JdEdXgP0JF{P7J%fIfMWu4OiD|@5rL&G z0rO0mz~WYbj8=g8W=ShRx7L6&0t-xfYrsi?($)aSoDx`_1mKs&d-xZbk|aR?WI*L) zfH9fLfany!7J(%ulmgf!ke>p0z-$)Cy$TR_6=12!y9!V{6|hraxrs>y@N3SDM=D^Y z*)A}(4IrTn;9*nP2GB4Ka8O{CiBALU6PT9c7Sf}0cQj@nDq95lLDpf0Z*Az0;@X!vN`~sF(n-U z{W}6GcLZ!SnH>Sqod8<|Hk(ijrqk>=&4o4oFJ}Y&Wyh0m^A8=0Vf4Ydjj^FQv$0q09hG; z_e@C!p#Rl?%2xwEFqu~aqI&_h2<$hZUVu#k`Mm%K%w~byYXEWA01leGYXG%-19l1= zGBLdY+XQCx27F?+3rxKhkZ>*FGgEjipy73Zg92Ze`0D`s1m;}__{!`TnAHc6)(22# zX7>Rk_XQjiIBHV*0*(kQ?F%?&$^;f)56HM4@SRz5J)m1Zz!`z#CcPivq(CV(=KvsXiPo|_lpnoQyawgyxlbH#K9st-PaLR-R05%Ea4*;Atn+0+Q0^$Y&&X~M` zfZBrqI|cqQF@pfx2Kmo7HxKf6_xsIufvH)fNXQ~Zlqt*tG#m^#C=fL9g8};l<_!i^ zGW!K)-2h0t0T42?ZvZ3@0UQ%J*Q5*q91&PL1W?(O2`tVgl#vanVwPkBx(x-K5vXd? zhXPItlnw<{Gp7Vr4+CTk1Jp1j!vOt<11b*()H0dF0ns^tEdntnlmpl#ke>sHHJb%; zM*!kR0OCyE2te(TfSm$$Ow35YHh~!<0rkvwfvLHGgj~R-rZ5-KFb{B0;Bph62iPYt zFAvbb>=&3d3XnDm5N~FW0wj+H9200{Qbq%g2rL~9NHApri^l*m#sHd{C1U{H@&RWA z5>0wO;G{rlKA?p;C9rxdAZsk3l_?nu=wAS+TmVQinFWC8aeyrXDJC=yut^|)93a(f z7RVhBh#L<`GkN0ywI={}3WQC}1i&_d8502Q&31vQ69EYm0Ub@@L_otyfP(^^P5dOl zK7o0Y0A0;~fmxFQX_EozX7*%2@{NFF0zFL1jesKpOK${Zm@YSVrSrk7cQG2NyT zeP#;Ly-oU5z)6A9setRuDS_36fUH75UsF;D=syimc^aUf$(+WI=;?qh0+}W>9k59t ze>z~G*({KI6Cmy;K$gk72~c|mV5h(hCT0d;o4|}2fNZl}VCv0)gqs1wOySLdhDCsb z0y!qW2(V9JUJ+oV*)K4w7?4&B$TPEx0m(A~#{@>3l$n4d0!wEC@=ck*;#&Y2w*U&v zl3M`XZUvkX7;n;V1)LNpy%jLgoDx`l8zAd8z+_W$8=(K~fXcT6rkKpz0nv8=wg?oO z&>etH0{M3Urkl+IxpxBM?gY#*d3OS8&jRceC^9j#0NVs+%mU0b+Xbf11|-Y|+-eGE z0~+21I4E$tiN6c5Phj3%fIH28fmw3^X>$Ox&FndVxEOqsyq zd4P<0fca+0JV3X*0cQjjnDn~=Ck0CH1~}%F!0P#ctoeXNrer>#|2=@p_W+E^yay1y z0I)@1i3u$LY!b*{0C>P`7RX%)h+7C)YVsBWYCC|P0?SQ|1K1`o!vU-`+XbfH3rM&Z z@USVo7tnAK;Gn=N6Tb+sPhj36z++~=z^wZKY4-t2%m5->n45$V4uLe6@WL)et}sl0ck4%+s*8ifaHe&#{_nml!pLE z1eQJo*lEfH7C#Kgco?wDEO{8v?GeBkf!!wk5x_}-(nkP$%_)J^s{mQ60PmTSRe=7F z0xCZW_`qa73W$CTuti|M2|WhbB#{3Y;DFgIkh>ZXw;FKJnK9IAijj0@QvQuv6d< z6Z14+o4|~x0e-VxVCpk~gl7Ozrtld+!)E~p1%f92S-?JldCvkWnf(H@HUiQ%0zzi? zMnLi=z%hYyP0A*~5rL(f0F_Odz~aq>GByLMm?fJ5-JS!S5vXd?p97o}D18o4&72Zg z{X8J+c|Z+Q@;spb3xLWm0BV`c7XZ;)09yoNOlS*WlR*9!K&;s;kh>KSw-pd)^0oqM zzX;eVP{+i)2-qet<3&I{vt3~7OMrxz0GFD=mjDf41{@T)+{C{O*e5XWWk3V7UtrcN zfV5Wt@n-fbfaF&J#{?Rglve>q1eU%ENHApri(dm|yas4$mb?b&_B!BfgBV6 z0brlNybk~)&3=Jd`v7VC0C{HiK0xw*z%hZ*CS^b1h``eQfP7OXu=qnj#)p6cv*bfS zw*!DP0^?2k0l-Ot(gT2r=9Iwdj{sR80VbQ0j{yA-0xBN_Ofi`U0nr}=wg?oO(8qvH z0{I^Urkl+IxrYF8hX6B7-XTEk!+@OvMJDDjV4J{012M}ZZ(CU02+P@ zI4E$tiT@O^Phj4sfIH28fmxpc(mn&sHnTqiB!3P#CNRgOd=5Awu=I1lJX0pH_zOVB z7l8R@$rpfbUjohuEHLR`0!|8)ehF~QDS_2r0kXaVEHWiu0s0>SR6YVQCi4g&x(u*I zV2KHp0X7NbmjNCyn+0;e2E=_0SZeaV2Gl+Z*eS5w#2f`|6PR%nu+nT7nEDMM;Tyoi zrtlj;!()Jh0;^2?F~B~7dB*^cnf(H@z6GRx3n($OzXc?J2RJ6M)}(v~I3lq0J3y%^ z6IlE`Ame+$I_|5Nk8}q!H-6zWM^IpZB6Zs3}m1>!rFAWR`&U}eR zY8LAJneqkm(xrh48!u=WxcZJobpwePuCOl=ML)0JG81jgq$dK+^xxdfiYEe>>18SR z*V^T|PYYKUII(MK&-1J#f^0(>-;Vrs}uv`FEZmg#+% z$O}%lSfa+^uGvBg{2>)i;J(h7{`ig?Kk_8rC3@oq-7h0w_rzXKPhk6@Mm0W@f zZMu6c({$W!*&-PKe05Q>GVqDKIaiNxs>h1l*XR_kj}mOc`)%e+VRd0F6yJj|MPG(y zBdwFAmR(NRLHaDS>s=*0=mVTonU z2?X@n2-maeHru@VRrdOpX+I)ZGnvRhZUt7&Wp?m$S-ihZT6;%kI4=n3RIP!M$KA562 zP?<9D`Ou~-Ql-a%s_1})y$Jtk6MkgbHL$S8m(M}VdJ}$)bXrg!TXrqsbXu>Q>LJUn zBYce={==5_f%T5O-}i}yeSw)a;ioYExo->PE5PS-o30<>v4piizp$)7VcmfA`O>mX z!g|$HpRX(%KzM@f+>ywOssn)&fm*d?HsK(`Q*FYpVf=GnNhq}J8=FqACFqW(&oRqx zAgs60_4(GaA%u6p^diT1mSt=Gy<-!8Z{biF@9?@;!Ewum!IqLvSHTI(h7(?E^XiRS z1#{4Qmi=hi2-t_Pw%DI68%el7tVoy3&lctq-Uw`m{l&68!Ya7~=A>n#2rm=oqgQo_ z_Kij>kyiJwmW?5-b<+)^4chc*z=h}3Igmov?=RBB#(~vsq{#~5&ZNlk5t#B>8Dwf?u_=wFMdAoTA zEb=!Ss@iln!{*UVExZe1{B!%JKm4I7)PAo~C`K8Sr%}^(@4gc`6X#PL^}H5VhlyK| zZb0f~oXvbIVcl%RF0t%3!n*&fmvt<=ov;?48eiA4I|whL1!}zR3;grlsW$4bO{n#k z*@UwQ-(#8X0R-Lqz5aBGX6p*e?jl@9cqUf&1*MyVzP3#F1+lqEqi_p0-m-awRqq`> zuAwU}yc?*B)l%I+lzBeVpTD4`?hQoj9;C*o-~^j)0b!+6!A&enwny$C-!Rv23|wKR zZVWuwssRaRaBsaC>E5pw<6dK^UPu2zx?}0UsRL#n(xGyw$=DQV5T|ovQ`8LU&Be>n z6{sPKHw!ie>eRc0pk5gcp>vQ-DxThni&d^8s6*fRqFc~y=ys&(nq|g6N52-C zmCpsLT{Q`!C8~>27n-gsEk$iTU68gY-CK1p?SLAhcv-*s_PIclqB)F(Uj0l!IvD80 zpo8BKT9S>1qTxt~yzxi}JH1Fb2IQ=eWU>4AEp z40JW><)@?9GPr$_emk-a3AO1zg`P&aNEfvBV7-6c4RumFl#EhPYoxnOb8HK=f(A6f zCZI%=Nt|96eiQ9LZ=o7A>Kt@#kbw>o_yzbI3H9!E78;CxWGeTdw~*es--=#BucFt{ zO7sZQ-yK+wHX!}cfcugDmVtI5?K;|IbgGIW8sAHS1 zsHW%)&G{X5WuV3)oiXCD-(cTCyV3h-AKH&TL?5B;Xa{-=?L;r3m(eTeRrDNMhnAoR z(1TiS-xD~FbRW|FX(ZBZLIQz8NR1xVUrjys#=qUOI zeUEg=x&i4=`{>X8=rvruv)e#_DM!Bwn1!G1`mIi21LkRBuGgr*Z&Yc!4y=_EE8 z>7b>9)l8(r)Xhj|EyA5{P&}! zXc@|bWuw7Je=kWV5uGxU@l()Ms0~Wf89Pki2@>gG_8Zcf`AeiTu}&8{dCnsKE~FdDU5wh1zGxIbMk8f@fl3#n4AcWPLhq+SkU zNNH7>qzWQ>m9+Za)fLta>HAhs)EAAREPXZ7-^@~de5)z)-ALdL;0$yt+JXNx_Cc(^ zRg|FpNZ%3;qOXv?9Xx~dg&+(0&>t8TDm_bh1zL%&K|0j;LCsMUq_cZH>bP9rvC;@A zlMmaD-b4x+N{dIJfhY^NF_SvE~2cv(R_3d z(&4Zd{7cIC3JujURmak!=o_R~m6G5=TTuDTIz{TW$_nUP(jG%9Fv1-hCtG(L1@PJS zu}+xv^B=)|7-=Kb)uo1RA^sk$F6&~XO*kK&A_w+=<2VWPFU+$hpFdH_Uqib!vu9R(s4y&T7n)zy0xkZ-DY(O%ts5+ zohTFOB&WH$8O=a9p{Yn`Ijt^j%QqrjyZSaa0S!ark+y5CLhjIriO*N& z`;a0GT7>RJ8fFKnP&Xk~=@hRx@xN9i7AZ^V?njzBNh7foJ&0DIG z6?z0chICgbMQhRH=n1qQtwS5oljtdQHOlxKyWQ-5gZ~Jl!FkP;y%C5l`on&-&{@mA zH&J8)cM+a}&O>h@#jE6<=xx*jy@ST05*E8A@*AYX!fNyqVdZ-deTgD%}H9%LYCR}O0MXKN+`VhT~ROo)JCVwCL05wDJBUP+$6O@2HLI;q_ z{sQgNQu&;~XXs<}2|A1pp-++gqo@pxLth~^>InK8DNcncPW%{BV=JSJX}Go>#m~V; z;&n>U@k;4#(*pz@+SG`iSRLqetBCaSJlx|*jr$&bhh9LMuAk5k=tgt`{fN$>pV6=A z6#507M5obj=ntg$-%(}iDVoj?4R=>mz9-T6YT+$dHBjHMiqZK~vh`k?EP_7>$=kMoee`Hn;bY`92^cOV*s z&LN?WpE+na8it0VAxK}HvysxtS6IE&bg9r>q+u>VPf*TS>?rg&;W60JC?EYf^lttl zcW5F*GKmD=kU?9v?r0P7H7eReB3GW`HLO!%$~PT5&Bp7>)0LyE?k3CBdvWETft4S* zO25$xxf!UPHFCwMz`tfzrMJQ(m1#eSG)Qwh8-EtM6WxK_%N47QPmNK2ZF;&QZ^x=r z+H1bl{Hp*}u0%?po0Rs0`ACarE>arxRv9(y^H3~OxG~bISNgkcSkof50NsPcBTQT! zP79k%h-)l{!w*B+4>YVD* zuB}dzugD!9LxRW7(c&v&mq21^m^elP}?Lu#%*U>X* zC>1=7eF{B^HlTIr2~>*Kqlu)6l&>ZE|smaHX^le7>bnt zJmFW-zt9e}4ZVSM?$r77O~Tu)uei6-PNXU$?TGY8b?nu0P)9z((de9Q8(}rsk4W$zoJi&W-{{m4F6N4rFJf=jy}hqsqH`!U!yYg75V~wiH@L? z=tuMoI*KA|^#{Tykk;z=*l&^6>M`^kI*xuuKcQdHDWo-j8s!Gqkv zt&a2J@@2b%Dq|_P$aevOb%3ha00mUT>Up4^>s3d(lxt$AlSbc6^n6e~P*`94#MO!V zNIe~h)O&^1OLayaxg4njYV>!+Hz0h49-mAFs6Y*A6Kn!%j2c<1m9A%R%}^E^gjyr< zf!IvcA8Ez+!(NZ{#6#2A6&txK`V#JgTA}Mu4|J{O|0>iD>5+*pr!LrQkRF}%MBPz3 z>V`U@j;I4_kHRPkC89{9S`t9~YM3fjgWFn`jMa0aqBi_UMQTI}QU+y|ltEUR z6js4%=wB;S55*&C%KNH35*Haojfy%+T#=h85}^Xhhm~2w6lsX8m>QX3xzg)_P$aM7 zRJiE4X~39DKF(uk5e>UmGu9Q>mSA3|8xCG}6AI1^ycM|>-wUz2Ti-!g1?ZBE6x5KgDw>bxAysrPR{7?l zNZG}N)qr^HXv(@<*MIpIP6aBl5~;VT8%Vi zN+YW@vTLm^&jy$N4~Zk0RblxIN*^ikX&a}?l|~&;9fIPYu=$Up@GdA*V|M{=_CNn>9&fJ2K7}fflj7YH<@F zK}=#*e`1{*YXA_Gq#1Wj^T`*17=CH~G$wW~=~x`aZKf4`z2dUPwMo~!2`L$6 z)AUQyJ;raS2Qp&Uldc-+QoD?NciV;wUm;y0=@Og!UNsw(ZkO5dWuS$BpZNn5du44e z`TZ%a&-s1Lhrg4&MU$i^E!a0r##hwaodl})=VeA{7rZGfCi|WFGj6 z^6oaf@LENF7rS8bt|~Xr>S;*cvPoh~l5emDJ^I^IZ|og^_YB*x<{Y-n%fAGw*G*Kf z_mZj#)wNqOW_!%ZF+aJfnrpm1HNB6};BQHAJ_*7n$2EGc(y>`2Xx4-(xaiF%F;OwC zE5)!6XaMed=%eQKPQ6Tm=1p2C!DYno#j*I7npba4IrP#IVp=v~5ZUTu%(q7ZwPRCB z5h6v_2OkzZ*vVh$=55`CHg+=g%BcMs5@@#0-}Bpvr%x?fPl8qyp2W@A6qM2bu_RFY zAImwmpws?eGfB{bIvCIYmxfobn5cU87=Qh!T2V>9qvkl}`Q3V}n>t?yg8rY){<*EHoZCR%NM|NNA(7uM*J?zXjgGrDtwdHHLyZZ(I3Q7r<2ICH^KetCV5Sy?kG zCN`I`A!qTB^kL`LpWXLEw}Gq>_B^xTXrNYHOW({(yiR`d`_3mCwyeCEB<>QjNn#>J zHLm0CTgC6L2!GxFlivopEpUsPYz`fz1;3l`hDX&jRlW(t1um#-ntT&z&bt@c-w<`b znJ)9RS@ca{BrhOjSB#3`-GJ#B)9hHFC9e-GO$Ti?MaNi$TQ6suqt&C+?wvJ$??-P? zRV#1m+*z+_wjT?`#Xi!&{X$mUV&Sl9FE3re5;G7@`Fi93mg-(Ju`;_&t8W7>652HM z3Y|E++wV`Wy6h&~Pln>JtM~$c7qjTwKt2AtO6B7e(9!HxIYZ6L?`YiZSGuRs;vcVk ze)EXXrh2-@xk6gAQJOj=@UJ%qm8+}yPTo$FuUzLPc~o@0!X>F>ZrSm>Xz+t28cVO;6jwffwHWF8WZw&rrIb|2gJ&Q>w1d zFmIe-+c|AcV*=+iH_d(sjEKFR3r)Mj!=rATT=@IIIB!X|V0k-c!w+OzYIgiUw%z6r z%*9*SKDqN2uN;;1%p0es{Xufl>SCza+8nMERojgCF>n!!aORKX-EI=QMKv~W{22Ja zf5a^RDG<{-nCkw5e{tte(_Vk!!OxzvONjlThK;#-{!?$&Isc;if5u#%YQFu63$m4| z^fOKAY*J-1kD6o&9`uX7?J7qNNt7kcJyy}P*Z7M!GVr=7Q@^x6FU=3DDl z`ch%sjDUC7u%-J~o0l7r$n9qgol307e)Qn!K+9@>Q>FRrbRd-%YwP?LhzSHbn5%vZ z^d!%nzXfK--qg|S&O=A1HJUW&hdb@`v)*iXl1$ne#;u(hFOy+1&Zpj`=EXDY@Pkd| z-|4aI#rPMS_VS)K1Aiyw4l^GUdtq1azP+Zbcw+LQrmy~a<-A}Hl00^C7rsO?Ad4Tp z^4Kq5jyU>ff)`EIKiG4*21TrItw;BB)- z>*j#zRX^$?Zw-B8HZ%aa1DRoJR-%#KXvUtt+8!~g^jn;l(J&ktj21q3FapuN%=za= z)xNl9FYi<}aNYBp-+q4I=YOVa*vniHjH>MoRBQ_A&SP-%8vZ{2g4`i{BI#QC?AUcS zhcuE$%>wTAu{UrD=&*L*1;y=KWIfSY7jUa4iCpyFVStORT1BSLX8yO^E<aoyej=9}oK=8<)q ztff(YnWUQ2S5U?0yoHBxrz^%kz>L3)EBIRy$Bypf?bX%ZtKa024G(OMjAaX-?fJh= zYwUEJyvk>buBhLv-$9b=6vRUFI%D>ob9UY%^Ln;tb4>elX~n-S`g_gp`ml1HW@#T( zGJE+o=<7A`=&0#;gsy76+#P}>oeGmoqw`qWy-2{Bt9bM;&$euPqJuV-Bo6B&7;Cbt zMOClZLi_tPvrBu)+1|Lj=UnqZLk8mTc~LFx2>Ks4O)HbmUZ2mHstn)R4%jJw!)#C* zJIuUsF;iO>lE6>2d}A8|J%A#s=FOb zR;Ob7n-x`}YPV`fin^ru_L_coAE`R#x<6A4A*LQN{RiB7{U-l2Y&nT?bxQ7?(b9;$L?J`w9V>!%hfT!6p%2s zm;^i-DBg0{l1pxS@40f#{KAZ{#qpgd;${me*|gSPNQS?i+2$Rxtodt=bE+JFFVdJ+zEQ;R z{h|1(&2##kt}*<{KV$AR3DwFq(`{IW*S=a&t-STAfZP6mBi;~s9aN9}HQbKL=(|fX z-R292z7?7E)uS$EE&e$IwF9lZ3<2Br*o(8h+uq>)-#58>#YM9tElg~cY>{b%>3FMk>05p zRe|f8)er;vj&EN7o#$p=QR{!s{Qo5ZdH$>Fy?w|Yk-R~V;lNQC!!2X9DdpRB?EPGP zoH>hc3%?uN{he)H84gydc17?Py4@ZWg$%uD@)*XbMp06fb43YQxjED*I8{?5z#dsxShACzEjPdv-VFtqt zhA}e+{l5F`eQ)JQ=KkTd&slr#wbxpEt?yd1}*IW11b(@lI1{ zhn?iA;R!~NrcE+A+rz{oDAgW=7)_>5i+0)nU!=kJZJslFArA$q>Ja>*9T1w+0m&F@ z@b0oO;`HFQOIjGyDh09__4IV@4&eHXK?5?@ZSE-qks92uSU)6 z!&AjVE?}}D4%H9tFHOfsloN4i!V*D$)637l7U`tfCq6qz`s1z_&F2%O9f+(`r+gCnI*DnXt?w|u8zDzZp zj6j}(9KnlXf0l1~vK{SC8Ndtx>kK;ZCoHrDQw3|+g&ce)pa9#>h9_2(-WguZmqK5< zC5O!66)4*k0SRL_t(sPwnMBh@5X)O;^LmQUH;o;`8h=|*OJLYyj5{&Eg2?LrE!0=v z9Z^CTERF+H`83MmtVUP1!o>7PuWKk18BF^XKu{oIL%t+mL}v!EuVkKApFXh_Hfk^d zo;w;GpwZInVnF#9^wy$x=AyS^56r)wZRqW$;wjO;H5`$eqIdxKZ%7}hYd6VFenp}x za$~^>w?Nv}4HDrNMb}x!%5?7U93Ni2Kc)49BE?P=@!ldAXXy1Y1+t6C8lF>{vlOf` z&7g8;DM({6k8HZbj|uSqvLqD{%KZ%$b_a|UAljsd5s=CWN!(C#noK)*dfdqhFd+79 z1;zIO9B4m}nz>>QJ$;5Ikia2!*Wgmb?hv7�<+*G8P?b6p2V&8jy^ry1J^AT-(|N zdqcrgmJaUB)c%~uec|*a$wykkp)9zG`5t8+ zfB~GKkxMTObDIrQEU0p3b#3(1i9f5Abt&f?Wn}A)Fn^ii+%ffH+UPE6^)A>Qtp3#< zAJ`dF8p)Vv_`=mq^~PnrCH?6C#Qs`MvSe7DQ9X`JWt!rscFDXQ*QI1$CAWMGlucC%}+q21V z!~q*oG@D~kcLWuAOFI2skTVVb-L!pymG7np8g-Sp^BOhi+*H+M=YvJ2l9vy(_B+M< zK!>O3kdKt3_NEcNaWkHl^v23(t>NkH%wv|se1ReJX{RqHKKvt$U%ecA7DWVCwik6Y8(ncGKz`V> zV?f6e-{`DXy;hd)`xtbrkc-_mgKGRR(*n}pr2ZJ_2qgwemb9V26b8`ukli{< zX8tIyT_d|FFsQ(LEfxD?uiT+4{?ECGKYtjhD5g5&yJZ802rN8`wv!cqO^f< z6#=9kgwcNa!v}d!7u39~EJc|UDMIf+ggb%HmGPZSFKy%c@}jMQ$|#QlF|^{QwD>rjUl3SH zA(vrLZSi)zG=!o1pM2)kr!;YK?a&t~o6$X@xFNXk&KlDlbTtV1zr2IvqhF(L-g&Yp zHAn~-meU1KT4TU5A=kq0ggUZa1w&zn(C~IcF{2*{@M2babCcZb;jT7p$BLra2nr7d zyOER+x|clW4EhI-Q(h?MjbC@zVMXLoc680QJ2uN2atK9v%av`2O*AM33*Jo@qcG4n z^e`0e8TTt_PY7;QQYpJAUK+_5vx!?&gIn&uV|XTL_n?_h&KvJLV|bh!vjAEnxPB*X zK<7vI>{&eri(+cG+DRdUS?t}(MUuLCa6sg)vY6U+=_z9{<_n-4T;z{I$I|0A9d9{Y zUA~SLpV|6hRnC}A)`Rh0$rtH(-!}{*5-*IfFcxaYSk0S?0qBGCg55uLtKQd^VaJ) z#dHdt4jDcS!`j44$O#oORXs@=j8Pbn=p|x$-J4n#)0y?wzgch384R4;96I=XfDVG= z`jidbETDbEYIk-0bqglA9w=rw)Ld^Ud2bOs z5&Q~*`j-Ma#E_6!wbIfV;E}Q<_U-~KNc3u8%?+@oY;kK(7{SehJet}J$Vj<;QDawY zKNEyyZThr{yWPR8`{GHhffP`ukr11(jMuxrx^gghOQGBbypV7?yz}em40iXDFE*IY zt7az44*}s8(AW>*AYVm*LQ}?QK)p7jU)Hto^n#$F&J8hOc*dP6<$NUB>U$pJ5!O1< z>Dr0{bE6h|s9xhop@lH|^&`}wBS|+#a(E>(ls86-LBKQ%haX5T=Duk2Ge5ttKWRRR zp;g7*tBR-(2=MXGk>OIX{>E``5Y{i+`yb0czYJ=}p$B}5sz(V=iOjz|d$y;^dghkl zXjouBMOV-j0HkvS;ME<_vAEth`{${X^WMHD45tS}gDWBs_@|!WNO(rXR{;ZiM-2x7 zKeonuJyncg&PjgmkkIbYu^%qJ>!nfao!u2gl1tqp!D}HMi-w9KBBidz=r105QhucL zt?9CF@G2jeNTalm0hUWh9*cg0MhWi5meNCukJ4@cNdt3#Lf^A7KBv25VfF%T9i^}+ zX@-#r4hQ+WI9h$ocUDJ5X>TC zE8627HQ-?77ewLX!OC)4#V(@P1FA+ZjZ{I; z#sgjjkyQ+!Xp^%P5F?fA7k$rdWpnWTj7pDfbNQqUg}ma8E8t`X)mBk(Eckf;9EYtw zW^}%bW!aJ1u6S1t1nL;di3J~1sR9={U6AiC-Ep}~m5KpthIils7nAJ-jJE~^ER#QQ zvv6H@`|cNN334eE1W01yCcu=!>Fqe6(pz+VB23UR9_Q4#6QmgSj~kAP*wl0(4w_LY zf>Atb9uGG7EHpY^3hA^w36(wkhOjRj;Mc@^N_2cmbdt0G^yKKIgvg0u$w{#ZOz0SOJQm1o?K3A3T<~=XYTG`F4{8=7CMHOJ-FB!ZB}Iq={ur4sl+S0qj>IV>Xnzb z-QU?oJl|b8t(9MY`Lr+EtlluO{c`I$$K&!s&~Aw~WfpHewa2AA0&NB@zdZL_?#}Qo z?Tb@zgCUTzJ5?pA<5zvR1Z^g*q2q>*ZZdy=$!fZjAlW(0n!?e>sl|Jrofs1Oc^2BN z!f+#bZfuLFL08sN=Sh;C#-f-4CQ0o^Srl{3{6)d}hXI}e>5tCx_PQ;n%5Her|7G}0 z?I8a@w*B_xtGi|}7dG7B^o36o|2p~T<>%=_pk{$ZC6lCOR#cQPHDfP`(!qD&!1Kt;xcnNA3y8HE4=0YMO>gb+x85Fj7~4GAg=3L-9{ zKtyl`5fD)!YE&GFiijhqI1eBj$E^}I@}1XO)f#=>`+45u`+j^s?1L+J-DlORxoXvF zv*Mkm-oa({ZcJ+ZYX0XHOW)a3@$vOSWRXP@{hP}*ns&E-l`7S!kYglep zVdA7|C0Ub;0LpkD*($;8tQlDorseoTwnt9T6KZLGUVcvE#0kFd@N470iKQ{6UT^w* z58x}Gr7gVlS7FtoQU7-0RiPDFjYkRgv=Rb^_QLfoy)HYsm6t(IVRqKEtcf`{!ByY_ zta@k`Rs~(mb?VAKShaXT8=voVY#vra)}XDI&q#a?#aevj(*gf%Y&~oVy;Is)HNn2q z&TG-&M4yj3l(vEMuhdEM#_kHN3e2&#C6-|1so@lD)LkZ&%Xy>d~V*f ziP>4RCJyfCRqQ}VrkEn8=1rfNSTM;~;VcX`&6?WT=To(^uqR_jV(VZTF^0(JTi?aY zZXMaGgI8eHAJ=#F2Jj86{25axCr-?p<(s73=gjb#ZeILS$A41Olm)huInyu8n?9+) z7oEVg$y} zbz07xS;Q_RR(%=o%&gg{WNJUpYuDeqW}0Rxsp?oB#H#O>_44{;&3Rr~A7W33Ux`&~ zuN&aatx5PA>M5kxb=i4|Zm(TNsaiAz>E3mP)3OS4eZD@v9Dq7z*dVV0IkRRJ%u39e z_c6XM=xKR&Zq~G^RP4{oGHddKPI_$9k{N@&?%I)IhZ?Jyb`iNNm*{RZBXL?@e%@@~ z9m6~xUF@ghYbwk=-|LR&v8q)LiP_PLrs6Ap(Qq&S9NWcpM!3x>DZO>5cj1p%&4SQK zuYd=snAYM?B-AXaX$va2z{_X?R->_Ul(*=w!YbW-tom=(Xm6h6%$t#uJ=^CSXyY%! zHY0wAJ1)+oP@9sJi@ZyF5T&{XFZTQ|$9b!=4e@p1lcyC-$eLE@tAnqiM`ika=VFtw znpz3icx=2)|10@4$Nzze3XfTDFR_8;k6h^Uv6Gg*f>rf5d45UhqYR1Ky*1ApnlSTLb0RdwvorE$WzEhh^hKB}O7|A& z)voCMZ!Qy0ceHn>dP6chf5tR5e#$m9J*bGTo#9l}YFhF+ z8=Z>$0ji;iuGR#mfOf_pwlQ`nP1BTkaE{l++p(IZW9=+Vw?ms^ZKJtfQ}3oenj!{Y z*KeY0bX_abVM|JL=XulnS*$8>dXZP{Pf4gIx1rz$*b01Q6q)b!ZBw|KcNjl}{lMB+ zu^NMkITJa0_c@5rpg(^_uE3HxN^~)@*?p>>hP{ExSc>Wn!^;>`p z>SJ@}vHJP^Y%|)$jWrH_4_4RZ%*)AU8vEWZ_4cWP={d8xpZmC}=Vd2On*I`8J@GU) z#LO*yn1EWg8LOc%WTY0fy~=B8JXSsP&6Qq;`B_sr9pue=4z7%1uo|N10DnL_b#Y-Y z@A@pKqIS#P8?W{HYj)9$oW#6B-KomGk+owEm?| z$2v_bycs!k2EIBbyP#ldUXE{&ucl4#?`yoC zI)c?4nUys+aYDhwqNJO=0?V+5tGd;_#jDNFt2}G)HA~W|rKV?}wO;y5{q8g^Da|RImZt^ayUlC#kLx_U z4PVvdK0RFne7B9i(%Pk1&F6_ZIWsg-zT`S})^k|xj#CN~i?Z^k`F7%Kl=3D|FPOz> zY{l28dN+r`g}&&WZa~nharAJs)E*bUE>i^? zJ00t_EV-Uk>h18|UNO-#aP;;#u^@Z)ti0(t`J_9ObR)3Z#LvIiyOj*Y*JMk^shKK`eym;~%wSao4KD@PUTfYl6W{-noavGUJ>pMo9sls80uuxe1) z@z-x!vVFIg`ZuhqlQnH}K_NHzr=Rvx@5I)E_kG68g=JKjo7LI3)y7YlGij2}2zfa< zIpMBde4U^5u3JUCnqAA*>gwmbL(lBOIkWRPgUx1{Pw@Gi_4VtO-1vfbO$JtFo%FnS z6Q9O4%3}z&8TKgMB)hc2>xtP|#dmwrYte=H>X~;)r?Id1l9%rVSPju8ta>b~uxNVr z)V$d=S^l`vEiZeG-v_8gf=l*#jctOJAB)wP-9@?(_G+vuvi}t?KAP?ce0Ab1;+6iu zKIggyXU1ji_ohzt0cte9vMq9UH)u3G@pUhD+G}1b9>&)U%*Iz?W3Wm+6srl?*ZOU+ zr{H(PYCIRd>BTqO(Yj$IuwzE!Q(6R*;Q?o1V%WdjsZ5LbUv_^sc8YpNg6A`71~^q| zsea>B_Kbu+!0$==pwl}g?BDGaMIxcWOrY~%G0yHzVgCxJG7|B>Xvtog5B)+0^;DUr&DrnI1+jz>dhU1?R z4%R)JnmAPjss3S3<$y@&TKsOrQtQ;PzuYMr7zzAzw)5z~p8hUQ<-kaA>Nz|fI_1f! zp)G_axJh>>g+p~)c=cv5sA*q3HIU)z7!Iz&>!E9cuMz6*UVX~BFgJzL55%(_NnSVL zrF(IzFy0V6zvHLl&vwcNNBj>vm4hRpgjQZ2#LNhX#^R}AF)EYkP&OnIc%zl`^N^nY zbDfloh(F&c;^#9?SwJo{<{dPpF?lp{8xUw$t_9!@*H_=ea3166)a;cS;R@ zN@%>x`nB`<#<-zd3H5YCKM}gX4HYK(d{f-eAwq-P(AFdd&kg-XXrLQ9uYELh1ECR4 z@%cS!5V*vR?AgKROLdA9Q$t0B26!#&9QN;Zibh02p^kb?R}U}D2!}@D{l1(+%kb2< zG=z!xnN1lZFW9mZjdaqM^{7GMJSVMPYUoZvUdJiHyKaK=E~)-AoU#idq3b&Pe3Qt` z?c~5Wot^HZdivWrMWZ62nM_pL;*Ct`emvF4?@qI?@Veuc0i0e3bo#iLc) zY}hECa4N?{LXBxLxU{CzyH7YY3@;V$WOqBd&M6xk2|WkXB4R1D4~J@`_GEB~B$j$2lqEBB7OJ#7wX)-;JkD!R`G}J%&Xi<98NP%M5}Ht=h`0 zFUHd{_4;o&p8A%!^TMI8@%YCQRycaLxR1HoIe4gg~oY~WV zj+1gpBy>5+hjN9_+1)GbuW-sPiTF=-Dv9Yw6E#jJxxK#tPyOcg@I!d&w;I|XL!aZR zel^`Xv|%{ae+ljiufXf*q|NG4qqonO;uMch_21xBj*o;s!slOU19wrLS3;ISoOoMPEo>DMzSmIARDcO-gtA0-R?4F@{ zRElE{m(mPdE5wxM3=VKRv$dgMV2z1c@v(lr!!N-fmeq(k51_sIxQpG z-%PvUP`tiQT3%}CaYE`HcVYy7%y1r^+B29*<=vL}n>s1eBB5#YiPui8)-8Cpe%->s zqj+xGU>mB?+im~Vgcx%&W&Q_W#bcXIO7)-OROUxQ{fB#d2C+TEOsAshkzfU^zpf27 zA3@(Kb+CX?n#=AdG}s-q`c7Fv#6QBREQo~e7|Au1;vO}EU*LJA&%2;nlY$T8^>u4? z7lWxuNiX#Z2fxJ2aB~ljcK2h-E+y1ohodQk|+J0} zQ-isLCMqiUGNHa=p~mB*)$;cb2M6Ir+_XywWvK}MgOr<1Q5I)XH|h;SIqtaSsgrxcd1hOlby;U)?W7SOP&M9vrf_cNO0gppKr7(xZHcmv$A zuRYby#ZUnutxIND-*D(&JZ^qkrCH(7r+BHZx0`*u=`?T0_g3IAJgpF}WBxBwoVzW) zKuBw!mCX!{$tQQG_`K9mIw7_)tyos`GCa*|>cwsQH9U82gwCAKQ38IFdmnxZkImWc z@4ftSALY`dWs@H&vbrsikxv>7^}=nQfZA#rb2T!+_1t1t8f zA&otI8?*K}Ub1_r=rGgk6OP6O;ZQD~TFTYb{2n~jiE}J{@;M%hhuNc}@$gw*?WrMm zx;w4Mb)0cecZ#lwgyt4T$3wS?Elwru8<^TaI!=u3W_z18{l`8u8_%1atiRw^yz%bj zuQNwSE-i!cguFdrHzBQkZ$xTd<{sWS_zfrI?&ZOyggCr)N)5bmnS0-8HaFS<6c)S) z&)badB*Y~JJ!%l>?^G@AQDa_o!dyX!y8y=x9e&@y|!;TTRJC#wwK$ghb9s78mDf#AJ3bndPevj zuN~L0zYk=ZUg5QgsYREK#q-)!M#$Y@gYm^$S-Pe2sI)v1d<*|Pr+7J&bOALcCyogn z*zWMy`Q?od2S39btTu!?lz7vL0}0b+JYLvs+kQgh+=E1^ZFs1NkakS(S>j8)q1pq3 z$qShWPI-sa&~!p}{au?Ji=)X!|1q6E$5UUpn}4X;mEH}*?use4`25$_WSBBiQzOQiz4d5z=_FI{UMWiMu8Cz9bwf z$Mf2usrw6FclRFOb*aXhM=<|Xr|8y5a2p-*6a-1KT;$_>@an~O(z)ONcUVt+eINRuSs=+2O`+?!7H&$w`?(0cAD zu@jZ8kA%L3b#wFA#BO<`b`Ww5%)HT=->GM4JHW0wHp0*FG`GA>GI50$$B^ZPLs@us zDB35-;tVAreRe5N19;jnX!G)LDEX%7*s_rQGn}G3cy@t#b5XM+=y*NO6uu)h=(WB# z2k0WF=*~!}j99ghyIpoT^aI`nc$_=gUB^2qcSVA?-^}$+@xavJ>x8%$O-K#ZTIr3O zw@C8w)GTHL^YuPFZ_)WvlVfpIb-IiecUt8|dAG1>cxu1rJ%p$I$y-j1jMpqLZWx{> zjrZ`e5Knn}ar^Mp<=)~7uJ*3;a!JEeM{sjtLKOcg?qNJt)63;+Javt`=Y=}1@xFBM z;v77s^zz(`rddWM~wBO+M3)>S5wg7LIdz=4=kW$f7`m53Hzu#cEt&YRfATu>`!=dGP>J!SM zU@l?7!3LzP)GY?7O0UuPK}5lx>fM3{0i5(^K=k)}zl^SuuBed4!yW zy~F-qPT7Nz&Z`!&OHFz;z2dDh19yJJ%UEkEuvxL0udG~f6QMY+p1ZKN7N&j_2!kk3_qNNf*2s zkFWnI_ftX|gBp6e2%fu>>Fsvg1VR_M-S!9}ZHwMX;x{~PCQNyjQNLZ$5!5sMHF#Pa z)S5Otjdy|Pv8WoBMSDjFmuYy)g_PX)p2F+rdE`>#QLnEkkJG{Vc$c{K*h*+jG{4|U zkGZD?o&^RGQr~*_#8r4hT~FU`e2Uk}Dc{a)dYpXV+|HP_hg!4uKVh`AdYi>J17|Dmm0@W$cQb-i9sMq5Y9;MI8J^p#lX zCqi0=v2GuXc`7>Dw8(G5)2Ohm(#vn)^~B?>!>Q!7-QJeVcZHXP{e7IGJrVyrr)*Co z_#`pzgEIg1Af+M_9RD;kz$x#X8hVM4HWY7Ug3m6bWv8P9s?LQfjEh^WL{~ zJc~02KEvzm)@k82;ZWlj`0fI)mb3(@wafw_&LR?+#d;T z-uruJup51h$Co(mQvEHRve)$GZRKl`z`u2h;ajlUsq0P7xjoGph@cD&~tcyY!kKLh;|s4 zga+WL6uPfNIJ5{)+k}_hZpFC|=_d$jA~ManCh}(W+^@&eHQpxlg7v(Ilo+SzU}{NA zpZlv|{QR>G;J0?EXKN5nw0?E#hb1A|_BLKNh`J!%X-M((i~Erk?}fyBBYpmxReC0=dmXo5w|w1)-Ot}yHHI6UdjWf< z`>AeKa0XJw!`xWUo$ckTV%h!JfbU(66m}%`LE_JtI_kt|TCs;14 zjB>31cUBdfY~y8>ehN}KQ#G_cXUn^dLJCZCz5H(*mFS`Zd3^rP)`1tJ#%LwdM^@Jv zIee;H^~O4+@@_{;cPG;4Z>%>gicrG4t-TkkPj#!-+~-oys#Tkj?ERL@D&00D&XL8f z$V1kD7^}}8cJN=pAHFi$g_Kd5hyS~E_I}si?a#+;YFS-fZvE<3&E+QNeq_~O&mfh` z=I?&~H&*$-fYk5olP9|u67cz*V~3i$-Mi0aKA)_LWm|KLVM}p8va#qrr1l2>6n_HgBP(A&6d!OM&-$Ij4;s0h5VZ8aSzTSz<`S}2zj&gLY(4B5*8jh-Zu$RL z7pjZ|eyBoCu^QYKSn+eMZ7GM3tkSi%ybZQCei*CK>*1$-0sVqcP3-wteg2!(_>3f- zG9G2qSGTIrIJnYXV&kh@A^j?zK9@RqKh|=l{TM5i=*k>o6gkPJkX3N9wYiqdD*bfp z%W5CG#`@K*CgydP%PM%i^<~wPWq!6{RryAnV1-Rk-3r}g;~g6>tLs)-zq)Mz-wam) zTd+#9)uxkG#U8|Jg*~dVP{PM;g6dYN+;Ul6xZC=&>WLSy+Q47MDr&!e{KYoJ|H5+F z`uM+C|Cb90DB}~>#;7)YWHno2u}T}lYSJ{s*2T8K>hpKj@2vZ{QHlDewM|vsYDem9 zd3CE&y1-?-VwEJ!59QNcj2e1=0a(#!wqE46D!ISw#)! zhwMn3PFBHD)?R4sSZl{wn`!N()@B9lz-C*JW9?*X^RVj2dDfqg)#tz2Q;5IDrju0z zueElu<+9>SbmLLrIvXLY;8N?$Dt?*uWz|zRVb!H8ZTu=M|9q?U!&-IqZPu4nKI^S7 zE8m&%^C_x>?+zPL-KwB_Eti#lKUQd~<+93XoAv+BDr!4FWOwjGOW|=jp7rKHIY2FX z%0|e_f5!T?}0$H{6 zC+o}Vg5%b&ZnZn8ma1qBKUBe*Sf!7}Dxca|U0T=jQ?W`{AFEIOb_5a#bi^uQXRPA7 z@k3n|kz=jj$^X1*mb~7U%EsYegcZu&7qR(0OTcg%k-v>7O6Hz|0npXd^zO3Kb`&-lI ziv7w`Srzt;^=17|?Gufh*+)*zQp$frPQ#u=*)6bbRR?QTt&Y~0RZg9;s$Lh%|EqP% zkF<2|KXIz_@`>1xu1?X_PU4r|9V=q<>Sb+jo9EwImDz`QHKe~yCo8Vkf|dI~%VovW ztuL$VhFBl#jjez>aTHb=Txb)>DuXfBmsR{lSfNWSuWpt8Qp;sk-~?<->=LZT{syel zEwAD9IeJ=iLcSHCs8w*KO?r!xnnb_fdrDj{m*@>jW35WK)AGBpDq#~=Nw)Aq@ef$L z1FIH1tVnB>-y=4@%-YATeG;qmyVX^Meb4EKwaR#p^<@=&nIFnrudn;u)@*1tDE1@*BJ)vYe*XSuBW^RU|AMp!PZ zijT9ttb*hDq4X25>Yp5}%9*4{*LrKq1?u=IHetR^INc`vZ&ugMBAp7FZPQn`;+NU{ z=Gu5!@uCs}8bMios#~@2dYf>WwacwtfmKUx!m4E}t-s2~ueSCUYj3soHmuU$Zf(h3 z1eDR;Ho?8tg52#uTY^5-t!m!drT?$L4XpF$uLGTgcf6 z)9-F1doR+by4C#t=LRh0b47GizD{R<{OJ2~0KVZ2$w?0JgLN=S7fVn0w36Prv*eg(E;@Sfmw+9rr2V8C{ z1oj9db^sKcq7Hz09RP;}N=)mHfL0v=%Q^xUnu7ud1kySIt};tH0Ty=x91~b%QaS^Y zI|J5r23%{72pks3=mJ<`)^q`^?gFS1xZb391q|#8*wPiS%v1^-7s%`eSZ+3T18nRD zs2v8ZFk{1jF=0TtfMY_*fY@X}ellRCDHGTwkdOi}CNBk$n*!J?u*Sr72Q=;uDDDne zYbpfx2=Eg3VE;N(lnR)a3OFRN-n8xkXw?I-tOwwBb5P)bKw28$PO~Hpus98HOyF*l z(i4!}6R@r);9he?;IIIHm1MAglUWl1td0Px1U8%WUVwqU09$$iwwOwR;{utz0o%-` z-hhq00k!)8wwtki0Au<9$^~|qP+vf7UqF6ez{93YV3$BbKfq3t*AI}}53pCD%*6Ev zH0}>5?hkm(R0!-5NIVZvZi>zW%sUToNZ?7+dH|r+0Kl>VfZgVxzyX1@fq-Ysl7WE5 z0|Cbbo---wfaG+*x^%z`=7_*yfs8?b3bSSqVD%tCmB33TUCVpmV8E8afW4+t;J85M z5WqgOX$WBB5J2q=z1a=7|38aL5!52h1A|I3)0aX*~kaY6M`}2*5|?puhovw2^>M z%#x9S#Ula71U@q<7XXqk0Ia(J@P#=da9AK?6yS(iGYYVJ6rf7rs7W6U7&scRWi;TJ zsT4RakjZ}Q|JrQ25U}w=KSKGP=CKiag)^w%*r zWcmmB{pMgMNe*O^B<&Kei7`tq0W7`*a7-X*QZ5A~UkX@vDWIk~B5+tBV>}>a){Fxq#;8puhovv^>DsW=S4kaUS59Kns&H1&}-iux<*Vr8y#SSRi96ptV^u z6|j0Lph}>vNuLH7I1R968X(bB3LF>6%m=hLoALo0^8vM|13H?q(*a|q1Ih(Dn@|BD zwg8Y{0O)GU1a=7|%m9Q<-V8wQ48UH26caZS(0C@GcqSm#R0!-5NSp;oGexri^JW1K z2}DfmLO`oRz_LO>Z*x%KfI!-8KwqdOFC0)tKZT)@D&fGu+Y8Kx58A8Llr!wfT!S^!wK0FY%43LFqfD*96`=OjfSG3O)qpWq z1Ih&oO=uAyb`ci?0J56If(Yt_LJv4_J3S z;97G;;IKf(Qos_kW+`CxQb3i!^(K88VBj*qmSuotrc&UzK;{jAf*YA*+@ zFk_bk#w-Vv3pgfpBOvxhK>m$@m8MK!mq5Y_fH8S10J$pwdj-~*xSIftZvqtG1Xyb- z1oj9dI)HVi$N|iA0EYzDo7Oi2THOp-b~E61b5P)bK-x;coo2~Oz~YsFV*+=ZlvRM_ zRe*J?0QZ_B0*3`M3}BO4V*slSph{q~NnZ^ZxEio!HDHUW6gV!BxdyP!Y+3`@xCT)B z7Ql8h_7=dHTL9$(J4|RTAa*Sve=Xo)Qzo!WAmLWPPLp>lAoo_lUV$+ zbQfUbU4Ytm1NNJ-cLT=U4Ja3Q-GuG|#NGqQzX$N9DHGTwkZ>>HZIgE|AopItUV(!q zZX=-aMnLgKz`LeGV2?oJCcq(6vAH}R&N1R2^=-)TLA;N0=8@g95a;y z#|1LC0lqeywgEP71Jr&1@U0p90AS1mfO3KFO=vqHb~_+{JKzUXCa_B&;X%MpChtK& z?t_560+l9i2cYo|K=BU1FQ!6Zk3ix>fGSh;5MbUzfJ1=53BPIcuudNjLzX>E62Ce4 zFi8#wq&)(NF-sl+EPe!VOdx1db^?-j0@m#W)HFu~4hv-L0))((U4YfQ0969DOnMn$ zU>RUb8KAbQ6gV!B`6!^S+4Lx2 z5=bZqG%|VRfZTGxUV%6h_XMEv6M*6;0P&_mV2?oJlYj(M^dw;3lYm14O-<{k0Ii+^ zEPD#j+#D1*Adt2jaJE^p8?bmc;Fv%Qlkzkm`DwtqrvWX^5rM-38P5P(n>Eh>RzCx% z5@>7Ep9Ktj7O>@6K%%J>I4+R+9H70~^c-O0bAZ~<13H?q&jZFh4=5MtY(g&pVqXB{ zzX0fJ$^>=^Bz4qnUIHw83DDad6gVJ|_A;QaS@JSq@ymc?0{uSU z0b*YRka@Wn9RRU8@`a6Ju?*O*E1IRa(0>=e1-vtzyP45CWz6+@R9$=;!`yOD- zdw_C*LK8X!h&=?zKLnU#$^>=^B)kupYx3R)$BanC$u+9`61M)xQAC{sp+*927Vpkai4kr&)3gu=p6@n84j8 zTl0o%-` zZvh*>1=Riyu-%OP4lw3BK)JvU6Z#$y`#m84d%(jx%f9!&8+1CftI;6(KUB(|mY1ae z6On#HY?0Yr>2Dbf@wQW4Q|~u_Q>8Sg{_Kx!@FtA6j!KnmZq9@mS=m#4J51uw{<*;e zO^7lbfA)`5@>Re1V}nD^;FnBImOt>)&hwiDuJD^ue_(@KZ1jH@RK3{sJ8S>ueNJb$0vC#3q5w{@|0hs%F%8pSk~xKx{Bb-_~)v z;-+@>)df3mO$hwz4=%k(z4k{J*^Z*S-gA4s*EwA5_PUxGaT{-LJSR{;IP57pcPGQM zBVaFbJLbJsfuYwl++bh*8M0H|KoLC(XJsdu{B3~_=B{mlX6`RBD@woGrq65~{Wm!M zhgez26r7&4LA%)q*`oSfA*NS*q~!mT79LV7=H9{iWrFmZ=ew z-7@$k<|{4Kt7Cb#;HxZC%hD~o+A_VNI?S>~mg&`slhr+ZqOXyiPWU)oBpiLEOs_8e ztZw7uzE-ARqSo7uzgW1$W~dhoYuF6+nweVC2u-)?uD49xTnJNrqQ8BjZk}h;=@m3x z%bN6EZP^Vl{^?KH`%3f*t3Ef{gsfCwJIhvBruUr|BaN%xWmB|dNTbcWnr-fT=4t z*bLhej=mapyJhWQ4M?YtUeMDhCZa}`-DA_~k3BSTUw$H>H}=%J_NbXnxY4o>u;!L+ zf+^S$ooiY2EkC`3)zUI8dj&hAwwCFwK9$i0C0bVUpoQ$RzrO{p*Z!2S8>&M3JY-pz z@M@RvmWgF-$-cFgJp$vO`{ySzEZYT8dEJqER-ebbYfJQ}Kz!=j=1A`us^A_d`g*Ni zHRPZB_bLu6lFySiT~ES2)xUh6vMfS)m~Gu|%X-1ix9n-ldc(%VX#Mfg=E6T;A2dw? zKH6MVUSBlVGHotm{gB@L(?{<(iuFfx72vbSvhxVfvrLm)L9Gz&fcm@`-MI$hykHZ) zWD{!H?6d4;%Lc*jvrI2jDmWOuVc9E|4S}6N8rFT5X*kv)eO|S!WGK!Cq%quY;V{CI z-XM6*vhxWKw=DYhru>nXMc?Ecf!~m8^wHa#s+ZElS@srI!3)rtdZk#O12*9(!l^dl zLCZ$N^wOL@?^t#r;rA?i*RnA%?QHtIht;$gi?p%z!G4HUWw_7!w6W>)QS_DKaX8Um zWc|b@yco8WD>O8p!c?B#Bv3Bu-Y;xAy;U%Tuv&T8vP%hn#09GS5tw$)@kmQr75&<# z%ToLAv+x@WC&09&s;1vsmQDC(3RXq+&Z{aj5%Idc`}ak=U=m=1((y~0liX4ym*|I5wRd6=;7t5v+R>5MwS~iWaUi()? zt1QbWtjZ|g-vYj~-GZmvgv$7YO*qe~pSs!W=AMgmKhHwv@l`^gWkM3c_NX~J2em*gQ7hEYWIP^d8q^Dtv1aDufkwf) z1nZe)j|bZGB|$l+zg`-vjp`u1QTYS<5&eX8Ti0FuS5$>G0sSa|bSKw~p?lFZ)3H1d z@1Jcl$^+y0vy&_{)E()sO0-3~{U)L$)E;$2%}{ex%N#5Zv`lPBun{VzoCQeJs1z+k zSD~xXB6KZUViKPSv>#ePa0Z%*W}!lK8JdfV(0p_`(xCN6+PXCLwF~t|x_7pcrPz|7 zx$lWU(j>jrruXKwwP_pFwx>TyF&<^1Y^3}545WLu-VvLM^io+i>W@aE3s4KL)!*Of zN?32tHATB9FWql?J{f3OGMqlV0O>7H-7|ELco6MCn$4QLnpApAbO7qBbSR9HQCFlJ zklt|ZgmhbPhfPEskd~$1a;!ivqL)y8>JUOF>utLl1bzhmLPEVEdNImG-!rIs+xI1; zw};Eoljv#mEZTtXM0%@QuP;A*o z8^XGs>-L?5ex)u|=sY?uAL-VvznXFsyAQpJ-b8Ps1Lz=n7wthWqLqI-&NA$?Il)Ec!#+B`SVVRs_Ec&GbP461>GNOyPL z&5xij(NXj@`X1?zoJ>Oc6DE3_FbADWI5o&L?|~CR&Cm#-ws>unqZo?qDg2n%0*L<{;1P5RDfol!;e|05Y0w&&}C>I zDnj#7v8nxZpnb_&g2ySh61~Mpy^ZuPx&8t`I?6ypk&Y@lnhZyy(HNu?$aFLZ>Exl4 zMpsloduO8ANGA=QEJ~416M9tAqmiCcI7pQEDu~#J9sxXx))8Kh?m#+0=)~|28jZ%H zOf(W*fOPOnz@CZr6Mh}Nf*wKlp>^n6^d0&h>2RPMzi#T8==DHN?-UScdOs6rlyDa1 z>%N|bbP7EewM4B@$jo_${?ehKH)E=IvU`z5FYJ5h5PAnai|#`=p_`G81n;1Ck&Xg- zJkaBSj{56RE^Iu?M32%89SwBb5924J6qJg3pq?@G*A^1#rl%X4Zug&|&yjBPx?NvO z{1T+6vBl^bq$9&2>}ISE#y_A5NQa?xGzj%ZeNbQ254A&y=w8yTq#>)2(c8}-P?HbQ z$LM{e=ZQ@yLil7<3!Q>|=sHz~xNFf$!pY!o;rc@WU!yH>{Sknz*c!wa(X-=GU8HBy zN)$uEdURaOwX-STJ(#v4vCf|puuov;aDm?7ord&;rC&oF%!PUlTTfSdni_}n0Ht5* z-i}tFTTmRzBcI2}+aMj92B9`cXHvb{tG9m(QHc^MQ%M;`^)wlrhd%%fMi-!|T&%z9 zGY4Hk_)4@0t;OGn4xsnY=jb7HF*-s1zoCcGdb9!QjBC%ZCGHbdBA^)=or8Ly2$jjA zz#McDx)|v^S%lIEe~i_cbg4uk`jbKTqo?qF*t;-yplpXM{Q21wD_c_vWPN%mo(NUxd+)w;kRQ)=g z$n?jVV$dFQ_XN87 zLj&uyY+`Yta&PJz9twf4gg>FU;Qa9g(6t4`T z=@hRx`F|}annqmd)*ua?q@K7Htwrn6Z75T>BLy~~JJ8)oOYcr}57Jh9Ke`WXMqAJ} zv=u#owxb781{(5LYlgqf_rK4A$C$jA1Mwy01W(wHrhNcapy&X;Lih@F3VI1CUOB&v z_M*;cAIeACtu&BFk#4y6q9+OKx;M~gC|cHj!sJ!LpLX>kHUVC<3B*peTousT)qpF_ zF{A?CLkH38NSPkME<|smw@?T4CQ`u)C!s|2E_w&4GM{S7sDMw<$LJ9H5Pg8&M<1aN z(U<5j(yaU(>6$Ol5u`X}ra19`Ayu|Eil^e*h!n58Tr^&{UL8@+r+nX41a$CGB?e=4 zC^|tn+Ddi(H%OKH8hwQxLmIAsqwkOw^|$DI^eg%SRifkQNAwf=8U2EOLyE6LC8to> ze5CF^4^?kTO?AeLh9mLHXQ9{RYKRON7M^ScPdQzsnY7TXphx_*F|dRprZ)-0>k3wOWPEM$zFpop7}9(+F#v6VVK$bM09u4n^~BLRb}Rj8*0I z#H-&cT~B~ zr~_(`TB5c{�=b?wC!H&d6H2XP{>29HjYjHa411JHl;HYorsF@=_kU{#*^I97zSp z>cVIu`I-2-A?PcC>XlH&olr-lj8(825zS9uFLXl-;9an)WLFf;uRGy*4XGFS|K6%H znrEu~7{VHr3$fbtG_0B`gSA35H#7kU5!M79fK5jOkun&K)kMAkI~?g^%`IK0m85Hj zVl_R6q4UuQG!l(M+FNwJ8k&pra5)L-(WgX?ChtXP96FhVIy6p1*=PdFLYE>vosLIJ zCtqQ;Qp2TuCL?w8bhL$h^09enGvTS&DQFt1*5f5^2I`tNmF`M- zw6N-%lNzv?xNFfhXc20FRERb{RYuoq)6eH?MG+#`;opkZqUrdz zU{@op3WL_5e(-y+s<>Jct+eKb##oiE1y`jt$yISp(!0^^=q`=_1_Ek<3fFQ{PXw{5 z;d-owLK*75qMh$fq>Gi&9cUl?CDhciQG_)l>gwpKP`uXtA=rE9ZS)p;Q{(>zdL8XX zkD({g6Q~^RM~|a2^eWni9!AfgSI|r7S@aOfqJSOP2hn!)0NRSSp!?A_G>bIR{FO&Y z7q|tRnQsM7FNv153%nDlEak1d9zm+#1QgBxQNmB7=g^Dj1@t`9xl`xQ3c`D=ueiPF zWuzjb^@z5IGD>`}5s}4(?_%FX(N1}ausY!&(gkYt0i*`%8l{iM%YO%{vF~Fm(T7MQ z8U1{W{}IwutA*;LPc$7$2`J(SI*dL?pQ6vu7w9MSJvxfMMA5nW9pP`0=IYnjV@PxL zU+63J4f+B78~uomBhC4r(PR#{lTePHAG6VTGy!FyOOd+rZlqdfals|9Oq7Jqz;BKH z6{~NRTB5VjS*RImiW+j=M5G0w3O6O~neYU325N%hP)TEcG(veKs)wzEYNJ}{WE4WW zH>o1AglnRckdEg;q{`JtzacH4Dr^8=1H~XeQrZ)i%UAq);8XP9#FTMez*g+3SU(9* z!!|_q(dkG_xdC=QY4q3@PgpHbSdV?;YD9CSmR^L^dWF?WHAW55cO7bgD*YAl=LQ)6 z7J#_`WvDLI7gp_1Thzu{&GdeR+oOxoIMfx1UxXclE<~E~qp_oqzVOg6o`;RDiVFyj zL|xDbG)Ut=9HpQL(l;hrPW`dNkiIz?jMC9SGywHQeNb=I3-v_ZPzMyPRA<7fKu4tI zsEVmjRXEMEFt$Wr{iLGqNR>!NxJ=JU z;?_(TMI-(i*2RNt#?cCisggr1*R}e3D0;2p)PwS)idI5a!=eqWpT=Ja1fv&gjFp+X zYb;WasNm>@3TqBjPp>$Q>u}2z{%d@7e?0NpZO4}o&^o^ZX$DtMG!b7l{VV&c|JTaP z*HCKbn~K#unu4@%XoCNOqIs04wb~?RVP~Qlr~pkz)8P47Jw$)RMTLZCqXp=4bPjwz zwg{a~crNxbL{j$;Qx_Ay0xdy{Q7O`rR3+qJtMM1O3P<~Z?wSh;Uy1nVe(!uW0qxgX zzo%h!w_Ze88EDDcjNDyN1>Jy_BIO(1z^=!S=B*xA1zKUJP`>*YtgF{>E(IvD5~;?~ z%v3QkoilDE?4T7$H=UcX>(N?t3tEZRpw(y1d@+JZKtdy$4rX=If~_C9N)tVDtP|3l*F#VRm*K{S0d z!yPtGg)2@CP{m8%;Rm1l@?%_ka*uJHx@FEu?%AwUw`PTT^K%L&wQJU~nfdztKu9Te z{`7v}`@qf`9|ul~<(Ft{eHn=3H|<+|8R*?Yu1=C;|bBIcNP zzYJu=FCg9Nq)R<-@*8`$pY}BAIwo~U>e$J*!W{aIbn8s!(LiVaJ!Sws zf4lFU-$>p$DV)@qnQA^b8i?!KxUpC6kGDP1e`&v?lid6|cBJ4o#PF~5w(oE4)2Qba zxBd~+$0YuXA}%&r|DwP`v%N`7eY5;ufna=z&F!9Fcf9cW%o~br?K(04%r+9o-%f(M zWZG-Pw2HXn(|&Lh&=brL^9h;8KTd)=B#0cJ(e}}r#}<>ILsAzdc+qq`7KjVH+1Ly@ z7HE9NcO>NTvGmG@L!U_b;HkqT?2^<;eSM;_DJ4aGD2}yAip;m)DY&(tzlao_lDZ{P znbXXUW0Z9!2{c@FUilH<)h|Vj3lc zePvDDeW3J)%>29>JwEBFa>KNtE9I_Jw$GZKUj;IFPa^m=lV%P>q-wrZCuRC+4F;#X z)$G)PmL$e|W3%ei(%zjjw=!uKXgYQ3;9F{Do*dIT{?#+QS+%yo&M%uRdVDIEcAx?D zfm@k|XQpt!P4Lo;PtUG(){;^0kft*;k2D$P>#u3uurs}0_~^I2TU&Lhy_y8>j8cN8 zzf#>l^7@&i>~N)TY>0f>`=ehkcB|^<)z{4YhNLf>g?TXz&F$X=5(4ixHBWsL=oCM; znK$Hddsc)FEqY+HtpFpMYifVXMOT`Z-v%c0Tkp%|Ei(JFnNH>322%K)_4Y$!;`~cZ zz3+%wYTC-U^Pr&__gx^N>#UaUqg!d`o3iKcUblhymIKkWSb$}tEl~vJcXvl3< zm!vM?@J(imvRQ9l_>M_@viSw?^yqIq7p&e_cfsNz=2U-u)AIX3bAMyA{s%g#UK{pl zvU{m;*`4{rL#!hfZ^xu=94}1sAIWZ{NtMYn+rP&wFa`1&n1%nwtTiWq@$a0!{m}Qv2fsW?sp8}J*j$~WZ-gD=a z%jOjQHZH-N-dayt#PIb~=~WNp>}!)UtjwKF9kf$SHJQiBX}wv2IpccvYb}u5r-UDV zp>qBScdlzG``+kkK0MB9Sjv=9iqXSg8k%+LLobkm8-!Aror#r!7{C7!ewCbk?)C0w z$j|I^pLBPBgSK?R@*OWXt<&VJKZ^doyD23FZ-%Y;nJS!a_R1s}|1a!qZBxA(=MA3P zp#4otO5Mxc8%|doOB+QdyjQz_eSgn1_OYa{9Y&aSzpy=RFh_r3HvaAY z!7gLBht9m=G4j{IKGyBAZZUDDM^&Ind{!?n?+eNvE4!*$&7TAQ4oUOen`^F_Sw;U( zF}u%iU*r)s?Q#p;`Y;O)0+gR z@309Tsyy?Z8%uB7b*ldklmA;FHSlvU)9wVlvdr|Z#opoG6+55Nw70h{+;+!lmu)N0 zYj~=^288{!G@3rgeAJor-eu;gwlPi2sxC22yzR#36X(Cod~_mO|2Qi9K`C9gp$RsawMu0No z%?GEEV5%7&h{^D`GwTCUFU~*74DS}xum%(6N^>m0g=GMfP|487rxwC23CMMn-ZBJ3&t=61VgSzZ6 zks4ebNcZ;B???CU@yy)u!rETIW}f^ zqn952FEU@tbLWli_s;P-)1$^d`p!ZNjP7-SJ+h=9Rluu6N5E zW~xr2p&t+Os{G^hRae$O`JS^$(1A?3UCl5ZYm(7}rlclSS!CAKjG4^*^2d_xjtp_rAH<^#l#n@T)sM%Ks&vyKWr!d(z*7|+2b*mU^&o*^0 zT%DKEDxylNvpf6#bGN-U)NH65)A)=}xmE|saoZj%d*!hMpZ;;}k3-F=r^Ph3T^e6= zn0N2YYxUdmQ*+0^7ERd2XM6c{GqWR=EHi7nYGI!o(X_{+xWLufymUL5T9fmQ*tkv-T$H9(Izrfqn>wdEG z+_O4dc!=C|<{~$@MbY&Wu!H)0qsE%yt;zV$Yh!|Gek!n9gPHRMLU!%`U`snX5(oyzw2}D9|?MxZn^`?T0O$0^h4U?Rv4BiQQ0bGyX4YW?RA%uA&pV zzH*^=IpqI-aPV;6s?TE0RuAB#LMh3?VDgWn_=>LnzTmL>~E(?Css(; zr_4Ii#eX!`n<8W9-&OuYgZH<(xhp}~XZ9>9k-n=ZZUZ_aD7ZS>`o zW7nBi(=+~aO@F=EY>gwY1arNbl$`19^xey@zu=b!6CaG$xT|lJd6EQwsc+I(D@~Y^(cw-BL_3BOgC_0^hJR zQI2lTx%;-))<5z`cJ8D6d;33nuDcRe**9fzsDaVM3=7XkG*~{`z zS^a*?9p5ZwXyDzc=7DCM9m`EsGt#G;M$Ng}?d(|X->@b=CQM>{krMiqg~9A zaK>G}Bl^}u4;WqeM$YX0Bi*XAVsg(|Sl}I?DwbVQr%~X|c{-=_T@t6pp9;*?XT_BI z115MjC)ORNAWRYN8jqI5Iw=pww2S3fqD?wzLg&PE4*W37^gJh~Q^0%PX>6`LC#Fl_ z^Fs5~Ijl@uYxadd&l-2Dh$7Rg#qal$=nat9x0kn|0``pHox9C@O8B7psRf-o)U?(4 z$~#d-)7jx|WVR^IcD21<8}rNW7sUC!8><=Ek{s>*)VrZabF_C}JBGRDL`xbQy@T0E zTf1k?!d4V_x>+mp=R44!4hw(D+q*nI!ha*u&8&auovMuk->Sg?(!teE8n)(tI!Wp9 zJ~Z&^d^4j>Oyh1JkVS|rF8-|Q==`Op@ZcZ4AO4Sbe*9)DGOKP;yxE2K|6R}zXY z*HGH+3)b*BtZrGsYn77s^YZQc>l+R1=t+qTqlji$gLkrBs+0$)&>AA<@}pbU(lDq0 zE&t?53O($#lIwrO%eEt{ir-Xq?w#i=+W05ODCXtm1V=2GMioeDcmy!jX9YeFYcHT5 z=fd5;sX6=840m@}17&z&U~>Gs1q4|12?TEbL|QrCSS{T-ppuSAxlN>IA_p^*&5y>DTp~OUlpc_Ihb2YZSbc z)mm7GE_cZ-)h96>UDB+a4KK_)x%T#E?Q};4ugLyibrGd9i~==9M}mFYUUF3HsGLP< zE=b{eM_vwK3D+aaaF86G%Corl8uReh{q!LZPJlLNZYWh4VNJljMcaSUA2G|DQO$dv zwRF<~ViAQ&0~u+g5WO$6XqH9_)@#nDqZ+s=QElkpu4sm;Xo@3pQC@wpHi4toxpqvx|$R(Es9|l1wq;ays zY~~PN{AEY}n>Gn7J7=vBxapo*Cwsmjl7m97l~f3A3(%c0s|PAvb;(+qm+^_oPwg9J z#>l=!kP6jj8=#BMV7A=S3E@9!o)ZH!%0znTB5BNStmk}R8`dY;W6jnmxveP2lRN9l z%N3kx0|e_*-1PCjaWkU*Ad5IoEI288Q@SfO!-V#`BEF3zwFmfUP2QfMCe#DexR8$< z0DLIM3nSQg*kWK&+#n zl1kX$oJPL-YNd=^qt~2EWfR~s5fY<8({i$y$-6phsCpv8c)>;y1(r=J{;0-p03>B^ z3$f$$jQ)&1DQPZ{|T@McWm(Rplv>j2&`w1TE`F6S1)_ zJNYXoX_KeC1+Ym)H$1UUZ~Dy>%?{3cwe341ZK#;|;p}N1BN%3!y+DdW9EZKY6(J~F z3h;&!pTZo*?LP)sR+)P3e4wX1B7S)`lw-3)w|QnmY#UBFn6YXc6%};M8`}z?24GO0 zp=aKZN)d%jlD3JyJ?Z&?I(HiG1C|B8$BXLa)q`3F8JYe8mWjX_MG-!bxb`a{OMlqC z#r)|bO{eznq8$uFdlB#bj4PO)dg=QV)-)9u^y!ih7*I~`zJSx=UmSTBR7;Bh(CJ@x z`*Q#Ci!V~RmE`G%0y1|i7tDzV1|}v_&U&mOyn$gcU%#!qZ{2Ox$ExSzY$3j2vgV~Ot9)8LdBLe|AC-csdv^QG!%XsBO zvnlihQ`N5mfHh+$gr+PTzOL3oCJ^T<_Vx?Oeu`A3tNkK)R!PbLP?krn2`E490;H)u zoj9RF-;NLYLX1c0SR%GzKyHC}oS=p5QBS+@(EG8Jt^`UBW<9qf9+%RnAjv_^{&xdw zKfd-=tCg{N5G(hEg=JG}5cDk{04#W(^xDxBr1)5S*a=#LLz zM`MEDG6t1;uUNvh$YzU0oiPGOCNnj7fo$>)2GQ&2Ej)CcDu_@>gi{4;x*sfAD3i%3 zL|UyLx`%7o!dG63JG3P(Oi#&_9AZKf???!cx=?FKCrb@Or6C4qarJ}ML>(t`>?n@n zLScR3v@%pWr*xo@Fqo&@ZB?0N9^jFn+#<59eciKB*qLZ>p)fcf20tp2a#?O@dxuNL z2Kx_kE$B@y;WDaq;h;u#jVgR+O&JfOe90&Z3bU!4M^xYXKixbVQgb`;?<0!{z}3)` zX?XC-dS8}PN`y4j=?Wr`T+Q@8NFff-Y7(fXC7?U3KA2L7jVta@H0F%mT*Xw8=jZ<`yDvf&$VX8M> zV6jgQfrEPicnzJ4Mks}q#Z$x#{ufsRbx8%+e1%)v;xhj{)?8vFV3LTS`$-LC>K7|H z|9^}*@H5o!-0B{-ufPo-YdTmMWcSUB81pp#o52Aw}xl(CYLIvgGA=I3| z^+YKs;Baj3!_=ja8p{k1U5-5TX4$%?ji>TKyD?^cQS8M_4k!6s`++ zS6kF7zEC-t{aVB81}XN~#gw)7&BaDui21|GrQy=%`?aVAQ!8AVp|P&)!fc$2ljT{keWI2-u}Pc1dn=`^cZ*Pvak%YHBj+F)@Tude z_Oe+Y22PncdpZF4(YZoHsSF^v9@nq2Qu0fWsxMz1<))`}vUQeAgCwe+16tQo#C)Xw zQFC#!(|;}^vo`#T@fXN@uJmt%=uhSUKAIImMhQsC3+PA!CJPuI*tKu+3>CiEVwVW_ z*)svJf5tP~!V`6M^DON*bdr`qD_PDaQn!5iHc?vEK^MlxB%qLq|r%|#<^!ir<=G&Ex7jRYTlCsG;g#RE;P}mBqU+O zXg^TsT|GxPlB6blfVg}iR@QMN4Y@dL6U0(80~m3UXTB5q(WSA28b9H?VpcPj?xsKo zoXI8`6r$3`Lmeu>D;o}98{3R4=REs?D~_a!WN;}S0E`zWzd2sK+0yPxCqNQLn0>Y{ zzE|MCXQg%L$TE7845hQ7t&7m0t|D~`l2Cd11pcO?q*UYwt7%s%NZ~8dy;Lc5)bHY^ z=gCEq%uoLL#d*o;8L>%8w&`;gE}oM{@oCanDoB&USDiyV?FSm(J3hQ}a8BjuYvO&` zspDfJ8XsK!7Vj)?37zzMQ(CRt<~A|zYT#B@R_zwtN!f8@my(=EDHu_ z)+{J9!@Du&Q_h*aXOG!8+2VaL-Va^8xBW=WSj#iM_`wuEG~Q{hU6Jta=WpPhv1{7g zY0-Vx{5&NR>&gzq|GqUFmoE>m|Hq`)ZRdY2@oexx9 zdKl;$m=(V$Ii9hh-_@6|*m!E{x{ueK=kUdQ&NhDSGU9jbM@9quem!{a@rQT6!Z=$d kENgvx>hJZBx{v=Lxa`fo0fg(bF&Wa^rYDBwN^jTv7a?w_$p8QV diff --git a/package.json b/package.json index b4cbd5c5a..10dba1ebc 100644 --- a/package.json +++ b/package.json @@ -62,6 +62,7 @@ "@microsoft/tsdoc": "^0.14.2", "@playwright/test": "^1.40.1", "argparse": "^2.0.1", + "chalk": "^5.4.1", "dotenv": "^16.3.1", "glob": "^10.3.10", "hi-base32": "^0.5.1", diff --git a/src/lib/ref_checker2.ts b/src/lib/ref_checker2.ts index 844995752..247ca65b9 100644 --- a/src/lib/ref_checker2.ts +++ b/src/lib/ref_checker2.ts @@ -3,6 +3,7 @@ import * as ts from 'ts-morph'; import path from 'path'; +import chalk from 'chalk'; import { getExpressionChain } from './utils'; const LIB_DIR = path.normalize(__dirname); @@ -28,8 +29,8 @@ function throwError( strPath: string, mutationType: 'function' | 'assignment' ) { - const mutationLine = getNodeLines(mutation, strPath); - const accessLine = getNodeLines(access, strPath); + const mutationLine = getNodeLines(mutation, strPath, 'yellow'); + const accessLine = getNodeLines(access, strPath, 'red'); if (mutationType === 'assignment') { const refRhs = @@ -39,18 +40,22 @@ function throwError( if (refRhs === undefined) { throw Error( - `Attempted to access "${access.getText()}" which may have been mutated.\nMutation: ${mutationLine}\nAccessed: ${accessLine}` + `Attempted to access "${access.getText()}" which may have been mutated. + +${mutationLine} Value mutated here. + +${accessLine} Attempted access of the value ocurred here` ); } const aliasInRef = refRhs.isKind(ts.SyntaxKind.Identifier) ? refRhs : refRhs.getDescendants().find((d) => aliases.map((a) => a.getText()).includes(d.getText()))!; - const staleRefLine = getNodeLines(aliasInRef!, strPath); + const staleRefLine = getNodeLines(aliasInRef!, strPath, 'yellow'); throw Error( `Attempted to access "${access.getText()}" which may have been mutated. You might want to use clone in the initial assignment -${staleRefLine} Initial assignment here. Suggestion: clone(${aliasInRef.getText()}) +${staleRefLine} Initial assignment here. ${chalk.bold.underline.yellow('Suggestion')}: clone(${aliasInRef.getText()}) ${mutationLine} Mutation of the value ocurred here. @@ -63,7 +68,9 @@ ${accessLine} Attempted access of the value occured here. throw Error( `Attempted to access "${access.getText()}" after it was passed to a function. You probably want to use clone in the function call -Function Call: ${mutationLine} Value passed to function here. Suggestion: clone(${access.getText()}) +Function Call: ${mutationLine} Value passed to function here. ${chalk.bold.underline.yellow( + 'Suggestion' + )}: clone(${access.getText()}) ${accessLine} Attempted access to value after passed to function here ` @@ -101,7 +108,33 @@ function includesNode(haystack: ts.Node, needle: ts.Node): boolean { }); } -function getNodeLines(node: ts.Node, pathStr: string) { +/** + * Colors a specific range of characters in a string using chalk + * @param text The input string to color + * @param startIndex The starting index of the range to color (inclusive) + * @param endIndex The ending index of the range to color (exclusive) + * @param color The chalk color to apply (e.g., 'red', 'blue', 'green') + * @returns The string with the specified range colored + */ +function colorRange(text: string, startIndex: number, endIndex: number, color: 'yellow' | 'red'): string { + // Validate indices + if (startIndex < 0 || endIndex > text.length || startIndex >= endIndex) { + throw new Error('Invalid range indices'); + } + + // Get the parts of the string + const beforeRange = text.substring(0, startIndex); + const coloredPart = text.substring(startIndex, endIndex); + const afterRange = text.substring(endIndex); + + // Apply color using chalk's dynamic method access + const coloredText = chalk[color](coloredPart); + + // Combine all parts + return beforeRange + coloredText + afterRange; +} + +function getNodeLines(node: ts.Node, pathStr: string, nodeColor: 'yellow' | 'red') { const nonTrimmedLine = node.getSourceFile().getFullText().split('\n')[node.getStartLineNumber() - 1]; const refFullLine = nonTrimmedLine.trim(); const char = ts.ts.getLineAndCharacterOfPosition( @@ -110,9 +143,12 @@ function getNodeLines(node: ts.Node, pathStr: string) { ).character; const nodeOffset = char - (nonTrimmedLine.length - refFullLine.length); - return `${pathStr}:${node.getStartLineNumber()}:${char}\n ${refFullLine}\n ${' '.repeat(nodeOffset)}${'^'.repeat( - node.getText().length - )}`; + return `${pathStr}:${node.getStartLineNumber()}:${char}\n ${colorRange( + refFullLine, + nodeOffset, + nodeOffset + node.getText().length, + nodeColor + )}\n ${' '.repeat(nodeOffset)}${chalk[nodeColor]('^').repeat(node.getText().length)}`; } function getAliases(node: ts.Node, methodBody: ts.Node) { @@ -245,7 +281,11 @@ function checkArrayFunctions(methodBody: ts.Node, pathStr: string) { const arg = c.getArguments()[0]; if (isArrayOrObject(arg) && !arg.getText().startsWith('clone(')) { const msg = `Mutable objects must be cloned via "clone" before being pushed into an array`; - throw Error(`${msg}\n${getNodeLines(arg, pathStr)} Suggestion: clone(${arg.getText()})`); + throw Error( + `${msg}\n${getNodeLines(arg, pathStr, 'yellow')} ${chalk.bold.underline.yellow( + 'Suggestion' + )}: clone(${arg.getText()})` + ); } } }