0xcaf6…ec3a

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a

The pipeline is behind the chain tip0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a

Everything already published is complete and correct; only newer blocks are missing. The chain summary reports this generation as behind the tip.

Verification

Code hash: 0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a
Status: full match
Provider: disassembly of package 0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a as `sui replay` fetched it at the version that executed
Compiler
Language: move-disassembly
Bundle: sha1:a805a8c6982ca50e38b500a8565278d180aaf76c

Sources

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/account.mvb442 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.account {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::fill;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct Account has copy, drop, store {
	epoch: u64,
	open_orders: VecSet<u128>,
	taker_volume: u128,
	maker_volume: u128,
	active_stake: u64,
	inactive_stake: u64,
	created_proposal: bool,
	voted_proposal: Option<ID>,
	unclaimed_rebates: Balances,
	settled_balances: Balances,
	owed_balances: Balances
}
public open_orders(Arg0: &Account): VecSet<u128> {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[0](Account.open_orders: VecSet<u128>)
ReadRef
Ret
}
public taker_volume(Arg0: &Account): u128 {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[1](Account.taker_volume: u128)
ReadRef
Ret
}
public maker_volume(Arg0: &Account): u128 {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[2](Account.maker_volume: u128)
ReadRef
Ret
}
public total_volume(Arg0: &Account): u128 {
B0:
CopyLoc[0](Arg0: &Account)
ImmBorrowField[1](Account.taker_volume: u128)
ReadRef
MoveLoc[0](Arg0: &Account)
ImmBorrowField[2](Account.maker_volume: u128)
ReadRef
Add
Ret
}
public active_stake(Arg0: &Account): u64 {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[3](Account.active_stake: u64)
ReadRef
Ret
}
public inactive_stake(Arg0: &Account): u64 {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[4](Account.inactive_stake: u64)
ReadRef
Ret
}
public created_proposal(Arg0: &Account): bool {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[5](Account.created_proposal: bool)
ReadRef
Ret
}
public voted_proposal(Arg0: &Account): Option<ID> {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[6](Account.voted_proposal: Option<ID>)
ReadRef
Ret
}
public settled_balances(Arg0: &Account): Balances {
B0:
MoveLoc[0](Arg0: &Account)
ImmBorrowField[7](Account.settled_balances: Balances)
ReadRef
Ret
}
public(friend) empty(Arg0: &TxContext): Account {
B0:
MoveLoc[0](Arg0: &TxContext)
Call tx_context::epoch(&TxContext): u64
Call vec_set::empty<u128>(): VecSet<u128>
LdU128(0)
LdU128(0)
LdU64(0)
LdU64(0)
LdFalse
Call option::none<ID>(): Option<ID>
Call balances::empty(): Balances
Call balances::empty(): Balances
Call balances::empty(): Balances
Pack[0](Account)
Ret
}
public(friend) update(Arg0: &mut Account, Arg1: &TxContext): u64 * u128 * u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u128
B0:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[8](Account.epoch: u64)
ReadRef
CopyLoc[1](Arg1: &TxContext)
Call tx_context::epoch(&TxContext): u64
Eq
BrFalse(15)
B1:
MoveLoc[0](Arg0: &mut Account)
Pop
MoveLoc[1](Arg1: &TxContext)
Pop
LdU64(0)
LdU128(0)
LdU64(0)
Ret
B2:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[8](Account.epoch: u64)
ReadRef
StLoc[3](loc1: u64)
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[2](Account.maker_volume: u128)
ReadRef
StLoc[4](loc2: u128)
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[3](Account.active_stake: u64)
ReadRef
StLoc[2](loc0: u64)
MoveLoc[1](Arg1: &TxContext)
Call tx_context::epoch(&TxContext): u64
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[8](Account.epoch: u64)
WriteRef
LdU128(0)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[2](Account.maker_volume: u128)
WriteRef
LdU128(0)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[1](Account.taker_volume: u128)
WriteRef
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[3](Account.active_stake: u64)
ReadRef
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[4](Account.inactive_stake: u64)
ReadRef
Add
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[3](Account.active_stake: u64)
WriteRef
LdU64(0)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[4](Account.inactive_stake: u64)
WriteRef
LdFalse
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[5](Account.created_proposal: bool)
WriteRef
Call option::none<ID>(): Option<ID>
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[6](Account.voted_proposal: Option<ID>)
WriteRef
MoveLoc[3](loc1: u64)
MoveLoc[4](loc2: u128)
MoveLoc[2](loc0: u64)
Ret
}
public(friend) process_maker_fill(Arg0: &mut Account, Arg1: &Fill) {
L2:	loc0: bool
L3:	loc1: u128
L4:	loc2: &mut VecSet<u128>
L5:	loc3: Balances
B0:
CopyLoc[1](Arg1: &Fill)
Call fill::get_settled_maker_quantities(&Fill): Balances
StLoc[5](loc3: Balances)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[7](Account.settled_balances: Balances)
MoveLoc[5](loc3: Balances)
Call balances::add_balances(&mut Balances, Balances)
CopyLoc[1](Arg1: &Fill)
Call fill::expired(&Fill): bool
Not
BrFalse(21)
B1:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[2](Account.maker_volume: u128)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::base_quantity(&Fill): u64
CastU128
Add
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[2](Account.maker_volume: u128)
WriteRef
B2:
CopyLoc[1](Arg1: &Fill)
Call fill::expired(&Fill): bool
BrFalse(27)
B3:
LdTrue
StLoc[2](loc0: bool)
Branch(30)
B4:
CopyLoc[1](Arg1: &Fill)
Call fill::completed(&Fill): bool
StLoc[2](loc0: bool)
B5:
MoveLoc[2](loc0: bool)
BrFalse(42)
B6:
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[0](Account.open_orders: VecSet<u128>)
StLoc[4](loc2: &mut VecSet<u128>)
MoveLoc[1](Arg1: &Fill)
Call fill::maker_order_id(&Fill): u128
StLoc[3](loc1: u128)
MoveLoc[4](loc2: &mut VecSet<u128>)
ImmBorrowLoc[3](loc1: u128)
Call vec_set::remove<u128>(&mut VecSet<u128>, &u128)
Branch(46)
B7:
MoveLoc[0](Arg0: &mut Account)
Pop
MoveLoc[1](Arg1: &Fill)
Pop
B8:
Ret
}
public(friend) add_taker_volume(Arg0: &mut Account, Arg1: u64) {
B0:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[1](Account.taker_volume: u128)
ReadRef
MoveLoc[1](Arg1: u64)
CastU128
Add
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[1](Account.taker_volume: u128)
WriteRef
Ret
}
public(friend) set_voted_proposal(Arg0: &mut Account, Arg1: Option<ID>): Option<ID> {
L2:	loc0: Option<ID>
B0:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[6](Account.voted_proposal: Option<ID>)
ReadRef
StLoc[2](loc0: Option<ID>)
MoveLoc[1](Arg1: Option<ID>)
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[6](Account.voted_proposal: Option<ID>)
WriteRef
MoveLoc[2](loc0: Option<ID>)
Ret
}
public(friend) set_created_proposal(Arg0: &mut Account, Arg1: bool) {
B0:
MoveLoc[1](Arg1: bool)
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[5](Account.created_proposal: bool)
WriteRef
Ret
}
public(friend) add_settled_balances(Arg0: &mut Account, Arg1: Balances) {
B0:
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[7](Account.settled_balances: Balances)
MoveLoc[1](Arg1: Balances)
Call balances::add_balances(&mut Balances, Balances)
Ret
}
public(friend) add_owed_balances(Arg0: &mut Account, Arg1: Balances) {
B0:
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[9](Account.owed_balances: Balances)
MoveLoc[1](Arg1: Balances)
Call balances::add_balances(&mut Balances, Balances)
Ret
}
public(friend) settle(Arg0: &mut Account): Balances * Balances {
L1:	loc0: Balances
L2:	loc1: Balances
B0:
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[7](Account.settled_balances: Balances)
Call balances::reset(&mut Balances): Balances
StLoc[2](loc1: Balances)
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[9](Account.owed_balances: Balances)
Call balances::reset(&mut Balances): Balances
StLoc[1](loc0: Balances)
MoveLoc[2](loc1: Balances)
MoveLoc[1](loc0: Balances)
Ret
}
public(friend) add_rebates(Arg0: &mut Account, Arg1: Balances) {
B0:
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[10](Account.unclaimed_rebates: Balances)
MoveLoc[1](Arg1: Balances)
Call balances::add_balances(&mut Balances, Balances)
Ret
}
public(friend) claim_rebates(Arg0: &mut Account): Balances {
L1:	loc0: Balances
B0:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[10](Account.unclaimed_rebates: Balances)
ReadRef
StLoc[1](loc0: Balances)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[7](Account.settled_balances: Balances)
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[10](Account.unclaimed_rebates: Balances)
ReadRef
Call balances::add_balances(&mut Balances, Balances)
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[10](Account.unclaimed_rebates: Balances)
Call balances::reset(&mut Balances): Balances
Pop
MoveLoc[1](loc0: Balances)
Ret
}
public(friend) add_order(Arg0: &mut Account, Arg1: u128) {
B0:
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[0](Account.open_orders: VecSet<u128>)
MoveLoc[1](Arg1: u128)
Call vec_set::insert<u128>(&mut VecSet<u128>, u128)
Ret
}
public(friend) remove_order(Arg0: &mut Account, Arg1: u128) {
B0:
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[0](Account.open_orders: VecSet<u128>)
ImmBorrowLoc[1](Arg1: u128)
Call vec_set::remove<u128>(&mut VecSet<u128>, &u128)
Ret
}
public(friend) add_stake(Arg0: &mut Account, Arg1: u64): u64 * u64 {
L2:	loc0: u64
B0:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[3](Account.active_stake: u64)
ReadRef
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[4](Account.inactive_stake: u64)
ReadRef
Add
StLoc[2](loc0: u64)
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[4](Account.inactive_stake: u64)
ReadRef
CopyLoc[1](Arg1: u64)
Add
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[4](Account.inactive_stake: u64)
WriteRef
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[9](Account.owed_balances: Balances)
MoveLoc[1](Arg1: u64)
Call balances::add_deep(&mut Balances, u64)
MoveLoc[2](loc0: u64)
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[3](Account.active_stake: u64)
ReadRef
MoveLoc[0](Arg0: &mut Account)
ImmBorrowField[4](Account.inactive_stake: u64)
ReadRef
Add
Ret
}
public(friend) remove_stake(Arg0: &mut Account) {
L1:	loc0: u64
B0:
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[3](Account.active_stake: u64)
ReadRef
CopyLoc[0](Arg0: &mut Account)
ImmBorrowField[4](Account.inactive_stake: u64)
ReadRef
Add
StLoc[1](loc0: u64)
LdU64(0)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[3](Account.active_stake: u64)
WriteRef
LdU64(0)
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[4](Account.inactive_stake: u64)
WriteRef
Call option::none<ID>(): Option<ID>
CopyLoc[0](Arg0: &mut Account)
MutBorrowField[6](Account.voted_proposal: Option<ID>)
WriteRef
MoveLoc[0](Arg0: &mut Account)
MutBorrowField[7](Account.settled_balances: Balances)
MoveLoc[1](loc0: u64)
Call balances::add_deep(&mut Balances, u64)
Ret
}
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/balance_manager.mvb751 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.balance_manager {
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct BalanceManager has store, key {
	id: UID,
	owner: address,
	balances: Bag,
	allow_listed: VecSet<ID>
}
struct BalanceManagerEvent has copy, drop {
	balance_manager_id: ID,
	owner: address
}
struct BalanceEvent has copy, drop {
	balance_manager_id: ID,
	asset: TypeName,
	amount: u64,
	deposit: bool
}
struct BalanceKey<phantom Ty0> has copy, drop, store {
	dummy_field: bool
}
struct TradeCap has store, key {
	id: UID,
	balance_manager_id: ID
}
struct DepositCap has store, key {
	id: UID,
	balance_manager_id: ID
}
struct WithdrawCap has store, key {
	id: UID,
	balance_manager_id: ID
}
struct TradeProof has drop {
	balance_manager_id: ID,
	trader: address
}
public new(Arg0: &mut TxContext): BalanceManager {
L1:	loc0: UID
B0:
CopyLoc[0](Arg0: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[1](loc0: UID)
ImmBorrowLoc[1](loc0: UID)
Call object::uid_to_inner(&UID): ID
CopyLoc[0](Arg0: &mut TxContext)
FreezeRef
Call tx_context::sender(&TxContext): address
Pack[1](BalanceManagerEvent)
Call event::emit<BalanceManagerEvent>(BalanceManagerEvent)
MoveLoc[1](loc0: UID)
CopyLoc[0](Arg0: &mut TxContext)
FreezeRef
Call tx_context::sender(&TxContext): address
MoveLoc[0](Arg0: &mut TxContext)
Call bag::new(&mut TxContext): Bag
Call vec_set::empty<ID>(): VecSet<ID>
Pack[0](BalanceManager)
Ret
}
public new_with_owner(Arg0: &mut TxContext, Arg1: address): BalanceManager {
L2:	loc0: UID
B0:
CopyLoc[0](Arg0: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[2](loc0: UID)
ImmBorrowLoc[2](loc0: UID)
Call object::uid_to_inner(&UID): ID
CopyLoc[1](Arg1: address)
Pack[1](BalanceManagerEvent)
Call event::emit<BalanceManagerEvent>(BalanceManagerEvent)
MoveLoc[2](loc0: UID)
MoveLoc[1](Arg1: address)
MoveLoc[0](Arg0: &mut TxContext)
Call bag::new(&mut TxContext): Bag
Call vec_set::empty<ID>(): VecSet<ID>
Pack[0](BalanceManager)
Ret
}
public balance<Ty0>(Arg0: &BalanceManager): u64 {
L1:	loc0: u64
L2:	loc1: BalanceKey<Ty0>
B0:
LdFalse
PackGeneric[0](BalanceKey<Ty0>)
StLoc[2](loc1: BalanceKey<Ty0>)
CopyLoc[0](Arg0: &BalanceManager)
ImmBorrowField[0](BalanceManager.balances: Bag)
CopyLoc[2](loc1: BalanceKey<Ty0>)
Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
Not
BrFalse(14)
B1:
MoveLoc[0](Arg0: &BalanceManager)
Pop
LdU64(0)
StLoc[1](loc0: u64)
Branch(20)
B2:
MoveLoc[0](Arg0: &BalanceManager)
ImmBorrowField[0](BalanceManager.balances: Bag)
MoveLoc[2](loc1: BalanceKey<Ty0>)
Call bag::borrow<BalanceKey<Ty0>, Balance<Ty0>>(&Bag, BalanceKey<Ty0>): &Balance<Ty0>
Call balance::value<Ty0>(&Balance<Ty0>): u64
StLoc[1](loc0: u64)
B3:
MoveLoc[1](loc0: u64)
Ret
}
public mint_trade_cap(Arg0: &mut BalanceManager, Arg1: &mut TxContext): TradeCap {
L2:	loc0: UID
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
CopyLoc[1](Arg1: &mut TxContext)
FreezeRef
Call validate_owner(&BalanceManager, &TxContext)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
Call vec_set::size<ID>(&VecSet<ID>): u64
LdConst[6](u64: 1000)
Lt
BrFalse(12)
B1:
Branch(18)
B2:
MoveLoc[1](Arg1: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
LdConst[4](u64: 4)
Abort
B3:
MoveLoc[1](Arg1: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[2](loc0: UID)
CopyLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
ImmBorrowLoc[2](loc0: UID)
Call object::uid_to_inner(&UID): ID
Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
MoveLoc[2](loc0: UID)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call object::id<BalanceManager>(&BalanceManager): ID
Pack[4](TradeCap)
Ret
}
public mint_deposit_cap(Arg0: &mut BalanceManager, Arg1: &mut TxContext): DepositCap {
L2:	loc0: UID
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
CopyLoc[1](Arg1: &mut TxContext)
FreezeRef
Call validate_owner(&BalanceManager, &TxContext)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
Call vec_set::size<ID>(&VecSet<ID>): u64
LdConst[6](u64: 1000)
Lt
BrFalse(12)
B1:
Branch(18)
B2:
MoveLoc[1](Arg1: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
LdConst[4](u64: 4)
Abort
B3:
MoveLoc[1](Arg1: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[2](loc0: UID)
CopyLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
ImmBorrowLoc[2](loc0: UID)
Call object::uid_to_inner(&UID): ID
Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
MoveLoc[2](loc0: UID)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call object::id<BalanceManager>(&BalanceManager): ID
Pack[5](DepositCap)
Ret
}
public mint_withdraw_cap(Arg0: &mut BalanceManager, Arg1: &mut TxContext): WithdrawCap {
L2:	loc0: UID
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
CopyLoc[1](Arg1: &mut TxContext)
FreezeRef
Call validate_owner(&BalanceManager, &TxContext)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
Call vec_set::size<ID>(&VecSet<ID>): u64
LdConst[6](u64: 1000)
Lt
BrFalse(12)
B1:
Branch(18)
B2:
MoveLoc[1](Arg1: &mut TxContext)
Pop
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
LdConst[4](u64: 4)
Abort
B3:
MoveLoc[1](Arg1: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[2](loc0: UID)
CopyLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
ImmBorrowLoc[2](loc0: UID)
Call object::uid_to_inner(&UID): ID
Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
MoveLoc[2](loc0: UID)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call object::id<BalanceManager>(&BalanceManager): ID
Pack[6](WithdrawCap)
Ret
}
public revoke_trade_cap(Arg0: &mut BalanceManager, Arg1: &ID, Arg2: &TxContext) {
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
MoveLoc[2](Arg2: &TxContext)
Call validate_owner(&BalanceManager, &TxContext)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
CopyLoc[1](Arg1: &ID)
Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
BrFalse(10)
B1:
Branch(16)
B2:
MoveLoc[1](Arg1: &ID)
Pop
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
LdConst[5](u64: 5)
Abort
B3:
MoveLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
MoveLoc[1](Arg1: &ID)
Call vec_set::remove<ID>(&mut VecSet<ID>, &ID)
Ret
}
public generate_proof_as_owner(Arg0: &mut BalanceManager, Arg1: &TxContext): TradeProof {
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
CopyLoc[1](Arg1: &TxContext)
Call validate_owner(&BalanceManager, &TxContext)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call object::id<BalanceManager>(&BalanceManager): ID
MoveLoc[1](Arg1: &TxContext)
Call tx_context::sender(&TxContext): address
Pack[7](TradeProof)
Ret
}
public generate_proof_as_trader(Arg0: &mut BalanceManager, Arg1: &TradeCap, Arg2: &TxContext): TradeProof {
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
MoveLoc[1](Arg1: &TradeCap)
Call validate_trader(&BalanceManager, &TradeCap)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call object::id<BalanceManager>(&BalanceManager): ID
MoveLoc[2](Arg2: &TxContext)
Call tx_context::sender(&TxContext): address
Pack[7](TradeProof)
Ret
}
public deposit<Ty0>(Arg0: &mut BalanceManager, Arg1: Coin<Ty0>, Arg2: &mut TxContext) {
L3:	loc0: TradeProof
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[1](Arg1: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
LdTrue
Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
CopyLoc[0](Arg0: &mut BalanceManager)
MoveLoc[2](Arg2: &mut TxContext)
FreezeRef
Call generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
StLoc[3](loc0: TradeProof)
MoveLoc[0](Arg0: &mut BalanceManager)
ImmBorrowLoc[3](loc0: TradeProof)
MoveLoc[1](Arg1: Coin<Ty0>)
Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
Call deposit_with_proof<Ty0>(&mut BalanceManager, &TradeProof, Balance<Ty0>)
Ret
}
public deposit_with_cap<Ty0>(Arg0: &mut BalanceManager, Arg1: &DepositCap, Arg2: Coin<Ty0>, Arg3: &TxContext) {
L4:	loc0: TradeProof
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[2](Arg2: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
LdTrue
Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
MoveLoc[1](Arg1: &DepositCap)
MoveLoc[3](Arg3: &TxContext)
Call generate_proof_as_depositor(&BalanceManager, &DepositCap, &TxContext): TradeProof
StLoc[4](loc0: TradeProof)
MoveLoc[0](Arg0: &mut BalanceManager)
ImmBorrowLoc[4](loc0: TradeProof)
MoveLoc[2](Arg2: Coin<Ty0>)
Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
Call deposit_with_proof<Ty0>(&mut BalanceManager, &TradeProof, Balance<Ty0>)
Ret
}
public withdraw_with_cap<Ty0>(Arg0: &mut BalanceManager, Arg1: &WithdrawCap, Arg2: u64, Arg3: &mut TxContext): Coin<Ty0> {
L4:	loc0: Coin<Ty0>
L5:	loc1: TradeProof
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
MoveLoc[1](Arg1: &WithdrawCap)
CopyLoc[3](Arg3: &mut TxContext)
FreezeRef
Call generate_proof_as_withdrawer(&BalanceManager, &WithdrawCap, &TxContext): TradeProof
StLoc[5](loc1: TradeProof)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowLoc[5](loc1: TradeProof)
MoveLoc[2](Arg2: u64)
LdFalse
Call withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
MoveLoc[3](Arg3: &mut TxContext)
Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
StLoc[4](loc0: Coin<Ty0>)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[4](loc0: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
LdFalse
Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
MoveLoc[4](loc0: Coin<Ty0>)
Ret
}
public withdraw<Ty0>(Arg0: &mut BalanceManager, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
L3:	loc0: Coin<Ty0>
L4:	loc1: TradeProof
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
CopyLoc[2](Arg2: &mut TxContext)
FreezeRef
Call generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
StLoc[4](loc1: TradeProof)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowLoc[4](loc1: TradeProof)
MoveLoc[1](Arg1: u64)
LdFalse
Call withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
MoveLoc[2](Arg2: &mut TxContext)
Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
StLoc[3](loc0: Coin<Ty0>)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[3](loc0: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
LdFalse
Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
MoveLoc[3](loc0: Coin<Ty0>)
Ret
}
public withdraw_all<Ty0>(Arg0: &mut BalanceManager, Arg1: &mut TxContext): Coin<Ty0> {
L2:	loc0: Coin<Ty0>
L3:	loc1: TradeProof
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
CopyLoc[1](Arg1: &mut TxContext)
FreezeRef
Call generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
StLoc[3](loc1: TradeProof)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowLoc[3](loc1: TradeProof)
LdU64(0)
LdTrue
Call withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
MoveLoc[1](Arg1: &mut TxContext)
Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
StLoc[2](loc0: Coin<Ty0>)
MoveLoc[0](Arg0: &mut BalanceManager)
FreezeRef
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[2](loc0: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
LdFalse
Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
MoveLoc[2](loc0: Coin<Ty0>)
Ret
}
public validate_proof(Arg0: &BalanceManager, Arg1: &TradeProof) {
B0:
MoveLoc[0](Arg0: &BalanceManager)
Call object::id<BalanceManager>(&BalanceManager): ID
MoveLoc[1](Arg1: &TradeProof)
ImmBorrowField[2](TradeProof.balance_manager_id: ID)
ReadRef
Eq
BrFalse(8)
B1:
Branch(10)
B2:
LdConst[2](u64: 2)
Abort
B3:
Ret
}
public owner(Arg0: &BalanceManager): address {
B0:
MoveLoc[0](Arg0: &BalanceManager)
ImmBorrowField[3](BalanceManager.owner: address)
ReadRef
Ret
}
public id(Arg0: &BalanceManager): ID {
B0:
MoveLoc[0](Arg0: &BalanceManager)
ImmBorrowField[4](BalanceManager.id: UID)
Call object::uid_to_inner(&UID): ID
Ret
}
public(friend) deposit_with_proof<Ty0>(Arg0: &mut BalanceManager, Arg1: &TradeProof, Arg2: Balance<Ty0>) {
L3:	loc0: BalanceKey<Ty0>
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
MoveLoc[1](Arg1: &TradeProof)
Call validate_proof(&BalanceManager, &TradeProof)
LdFalse
PackGeneric[0](BalanceKey<Ty0>)
StLoc[3](loc0: BalanceKey<Ty0>)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowField[0](BalanceManager.balances: Bag)
CopyLoc[3](loc0: BalanceKey<Ty0>)
Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
BrFalse(20)
B1:
MoveLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[0](BalanceManager.balances: Bag)
MoveLoc[3](loc0: BalanceKey<Ty0>)
Call bag::borrow_mut<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): &mut Balance<Ty0>
MoveLoc[2](Arg2: Balance<Ty0>)
Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
Pop
Branch(25)
B2:
MoveLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[0](BalanceManager.balances: Bag)
MoveLoc[3](loc0: BalanceKey<Ty0>)
MoveLoc[2](Arg2: Balance<Ty0>)
Call bag::add<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>, Balance<Ty0>)
B3:
Ret
}
public(friend) generate_proof_as_depositor(Arg0: &BalanceManager, Arg1: &DepositCap, Arg2: &TxContext): TradeProof {
B0:
CopyLoc[0](Arg0: &BalanceManager)
MoveLoc[1](Arg1: &DepositCap)
Call validate_deposit_cap(&BalanceManager, &DepositCap)
MoveLoc[0](Arg0: &BalanceManager)
Call object::id<BalanceManager>(&BalanceManager): ID
MoveLoc[2](Arg2: &TxContext)
Call tx_context::sender(&TxContext): address
Pack[7](TradeProof)
Ret
}
public(friend) generate_proof_as_withdrawer(Arg0: &BalanceManager, Arg1: &WithdrawCap, Arg2: &TxContext): TradeProof {
B0:
CopyLoc[0](Arg0: &BalanceManager)
MoveLoc[1](Arg1: &WithdrawCap)
Call validate_withdraw_cap(&BalanceManager, &WithdrawCap)
MoveLoc[0](Arg0: &BalanceManager)
Call object::id<BalanceManager>(&BalanceManager): ID
MoveLoc[2](Arg2: &TxContext)
Call tx_context::sender(&TxContext): address
Pack[7](TradeProof)
Ret
}
public(friend) withdraw_with_proof<Ty0>(Arg0: &mut BalanceManager, Arg1: &TradeProof, Arg2: u64, Arg3: bool): Balance<Ty0> {
L4:	loc0: Balance<Ty0>
L5:	loc1: Balance<Ty0>
L6:	loc2: Balance<Ty0>
L7:	loc3: &mut Balance<Ty0>
L8:	loc4: u64
L9:	loc5: BalanceKey<Ty0>
L10:	loc6: bool
B0:
CopyLoc[0](Arg0: &mut BalanceManager)
FreezeRef
MoveLoc[1](Arg1: &TradeProof)
Call validate_proof(&BalanceManager, &TradeProof)
LdFalse
PackGeneric[0](BalanceKey<Ty0>)
StLoc[9](loc5: BalanceKey<Ty0>)
CopyLoc[0](Arg0: &mut BalanceManager)
ImmBorrowField[0](BalanceManager.balances: Bag)
CopyLoc[9](loc5: BalanceKey<Ty0>)
Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
StLoc[10](loc6: bool)
MoveLoc[3](Arg3: bool)
BrFalse(29)
B1:
MoveLoc[10](loc6: bool)
BrFalse(22)
B2:
MoveLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[0](BalanceManager.balances: Bag)
MoveLoc[9](loc5: BalanceKey<Ty0>)
Call bag::remove<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): Balance<Ty0>
StLoc[4](loc0: Balance<Ty0>)
Branch(26)
B3:
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
Call balance::zero<Ty0>(): Balance<Ty0>
StLoc[4](loc0: Balance<Ty0>)
B4:
MoveLoc[4](loc0: Balance<Ty0>)
StLoc[6](loc2: Balance<Ty0>)
Branch(76)
B5:
MoveLoc[10](loc6: bool)
BrFalse(32)
B6:
Branch(36)
B7:
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
LdConst[3](u64: 3)
Abort
B8:
CopyLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[0](BalanceManager.balances: Bag)
CopyLoc[9](loc5: BalanceKey<Ty0>)
Call bag::borrow_mut<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): &mut Balance<Ty0>
StLoc[7](loc3: &mut Balance<Ty0>)
CopyLoc[7](loc3: &mut Balance<Ty0>)
FreezeRef
Call balance::value<Ty0>(&Balance<Ty0>): u64
StLoc[8](loc4: u64)
CopyLoc[8](loc4: u64)
CopyLoc[2](Arg2: u64)
Ge
BrFalse(50)
B9:
Branch(56)
B10:
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
MoveLoc[7](loc3: &mut Balance<Ty0>)
Pop
LdConst[3](u64: 3)
Abort
B11:
CopyLoc[2](Arg2: u64)
MoveLoc[8](loc4: u64)
Eq
BrFalse(68)
B12:
MoveLoc[7](loc3: &mut Balance<Ty0>)
Pop
MoveLoc[0](Arg0: &mut BalanceManager)
MutBorrowField[0](BalanceManager.balances: Bag)
MoveLoc[9](loc5: BalanceKey<Ty0>)
Call bag::remove<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): Balance<Ty0>
StLoc[5](loc1: Balance<Ty0>)
Branch(74)
B13:
MoveLoc[0](Arg0: &mut BalanceManager)
Pop
MoveLoc[7](loc3: &mut Balance<Ty0>)
MoveLoc[2](Arg2: u64)
Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
StLoc[5](loc1: Balance<Ty0>)
B14:
MoveLoc[5](loc1: Balance<Ty0>)
StLoc[6](loc2: Balance<Ty0>)
B15:
MoveLoc[6](loc2: Balance<Ty0>)
Ret
}
public(friend) delete(Arg0: BalanceManager) {
L1:	loc0: Bag
B0:
MoveLoc[0](Arg0: BalanceManager)
Unpack[0](BalanceManager)
Pop
StLoc[1](loc0: Bag)
Pop
Call object::delete(UID)
MoveLoc[1](loc0: Bag)
Call bag::destroy_empty(Bag)
Ret
}
public(friend) trader(Arg0: &TradeProof): address {
B0:
MoveLoc[0](Arg0: &TradeProof)
ImmBorrowField[5](TradeProof.trader: address)
ReadRef
Ret
}
public(friend) emit_balance_event(Arg0: &BalanceManager, Arg1: TypeName, Arg2: u64, Arg3: bool) {
B0:
MoveLoc[0](Arg0: &BalanceManager)
Call id(&BalanceManager): ID
MoveLoc[1](Arg1: TypeName)
MoveLoc[2](Arg2: u64)
MoveLoc[3](Arg3: bool)
Pack[2](BalanceEvent)
Call event::emit<BalanceEvent>(BalanceEvent)
Ret
}
validate_owner(Arg0: &BalanceManager, Arg1: &TxContext) {
B0:
MoveLoc[1](Arg1: &TxContext)
Call tx_context::sender(&TxContext): address
MoveLoc[0](Arg0: &BalanceManager)
Call owner(&BalanceManager): address
Eq
BrFalse(7)
B1:
Branch(9)
B2:
LdConst[0](u64: 0)
Abort
B3:
Ret
}
validate_trader(Arg0: &BalanceManager, Arg1: &TradeCap) {
B0:
MoveLoc[0](Arg0: &BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
MoveLoc[1](Arg1: &TradeCap)
Call object::borrow_id<TradeCap>(&TradeCap): &ID
Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
BrFalse(7)
B1:
Branch(9)
B2:
LdConst[1](u64: 1)
Abort
B3:
Ret
}
validate_deposit_cap(Arg0: &BalanceManager, Arg1: &DepositCap) {
B0:
MoveLoc[0](Arg0: &BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
MoveLoc[1](Arg1: &DepositCap)
Call object::borrow_id<DepositCap>(&DepositCap): &ID
Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
BrFalse(7)
B1:
Branch(9)
B2:
LdConst[1](u64: 1)
Abort
B3:
Ret
}
validate_withdraw_cap(Arg0: &BalanceManager, Arg1: &WithdrawCap) {
B0:
MoveLoc[0](Arg0: &BalanceManager)
ImmBorrowField[1](BalanceManager.allow_listed: VecSet<ID>)
MoveLoc[1](Arg1: &WithdrawCap)
Call object::borrow_id<WithdrawCap>(&WithdrawCap): &ID
Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
BrFalse(7)
B1:
Branch(9)
B2:
LdConst[1](u64: 1)
Abort
B3:
Ret
}
Constants [
=> u64: 0
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 1000
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/balances.mvb221 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.balances {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
struct Balances has copy, drop, store {
	base: u64,
	quote: u64,
	deep: u64
}
public(friend) empty(): Balances {
B0:
LdU64(0)
LdU64(0)
LdU64(0)
Pack[0](Balances)
Ret
}
public(friend) new(Arg0: u64, Arg1: u64, Arg2: u64): Balances {
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
Pack[0](Balances)
Ret
}
public(friend) reset(Arg0: &mut Balances): Balances {
L1:	loc0: Balances
B0:
CopyLoc[0](Arg0: &mut Balances)
ReadRef
StLoc[1](loc0: Balances)
LdU64(0)
CopyLoc[0](Arg0: &mut Balances)
MutBorrowField[0](Balances.base: u64)
WriteRef
LdU64(0)
CopyLoc[0](Arg0: &mut Balances)
MutBorrowField[1](Balances.quote: u64)
WriteRef
LdU64(0)
MoveLoc[0](Arg0: &mut Balances)
MutBorrowField[2](Balances.deep: u64)
WriteRef
MoveLoc[1](loc0: Balances)
Ret
}
public(friend) add_balances(Arg0: &mut Balances, Arg1: Balances) {
B0:
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
ImmBorrowLoc[1](Arg1: Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
Add
CopyLoc[0](Arg0: &mut Balances)
MutBorrowField[0](Balances.base: u64)
WriteRef
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
ImmBorrowLoc[1](Arg1: Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
Add
CopyLoc[0](Arg0: &mut Balances)
MutBorrowField[1](Balances.quote: u64)
WriteRef
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[2](Balances.deep: u64)
ReadRef
ImmBorrowLoc[1](Arg1: Balances)
ImmBorrowField[2](Balances.deep: u64)
ReadRef
Add
MoveLoc[0](Arg0: &mut Balances)
MutBorrowField[2](Balances.deep: u64)
WriteRef
Ret
}
public(friend) add_base(Arg0: &mut Balances, Arg1: u64) {
B0:
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Add
MoveLoc[0](Arg0: &mut Balances)
MutBorrowField[0](Balances.base: u64)
WriteRef
Ret
}
public(friend) add_quote(Arg0: &mut Balances, Arg1: u64) {
B0:
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Add
MoveLoc[0](Arg0: &mut Balances)
MutBorrowField[1](Balances.quote: u64)
WriteRef
Ret
}
public(friend) add_deep(Arg0: &mut Balances, Arg1: u64) {
B0:
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[2](Balances.deep: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Add
MoveLoc[0](Arg0: &mut Balances)
MutBorrowField[2](Balances.deep: u64)
WriteRef
Ret
}
public(friend) base(Arg0: &Balances): u64 {
B0:
MoveLoc[0](Arg0: &Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
Ret
}
public(friend) quote(Arg0: &Balances): u64 {
B0:
MoveLoc[0](Arg0: &Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
Ret
}
public(friend) deep(Arg0: &Balances): u64 {
B0:
MoveLoc[0](Arg0: &Balances)
ImmBorrowField[2](Balances.deep: u64)
ReadRef
Ret
}
public(friend) mul(Arg0: &mut Balances, Arg1: u64) {
B0:
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
CopyLoc[1](Arg1: u64)
Call math::mul(u64, u64): u64
CopyLoc[0](Arg0: &mut Balances)
MutBorrowField[0](Balances.base: u64)
WriteRef
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
CopyLoc[1](Arg1: u64)
Call math::mul(u64, u64): u64
CopyLoc[0](Arg0: &mut Balances)
MutBorrowField[1](Balances.quote: u64)
WriteRef
CopyLoc[0](Arg0: &mut Balances)
ImmBorrowField[2](Balances.deep: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Call math::mul(u64, u64): u64
MoveLoc[0](Arg0: &mut Balances)
MutBorrowField[2](Balances.deep: u64)
WriteRef
Ret
}
public(friend) non_zero_value(Arg0: &Balances): u64 {
L1:	loc0: u64
L2:	loc1: u64
B0:
CopyLoc[0](Arg0: &Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
LdU64(0)
Gt
BrFalse(11)
B1:
MoveLoc[0](Arg0: &Balances)
ImmBorrowField[0](Balances.base: u64)
ReadRef
StLoc[2](loc1: u64)
Branch(28)
B2:
CopyLoc[0](Arg0: &Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
LdU64(0)
Gt
BrFalse(22)
B3:
MoveLoc[0](Arg0: &Balances)
ImmBorrowField[1](Balances.quote: u64)
ReadRef
StLoc[1](loc0: u64)
Branch(26)
B4:
MoveLoc[0](Arg0: &Balances)
ImmBorrowField[2](Balances.deep: u64)
ReadRef
StLoc[1](loc0: u64)
B5:
MoveLoc[1](loc0: u64)
StLoc[2](loc1: u64)
B6:
MoveLoc[2](loc1: u64)
Ret
}
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/big_vector.mvb2611 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.big_vector {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct BigVector<phantom Ty0: store> has store, key {
	id: UID,
	depth: u8,
	length: u64,
	max_slice_size: u64,
	max_fan_out: u64,
	root_id: u64,
	last_id: u64
}
struct Slice<Ty0: store> has drop, store {
	prev: u64,
	next: u64,
	keys: vector<u128>,
	vals: vector<Ty0>
}
struct SliceRef has copy, drop, store {
	ix: u64
}
public(friend) empty<Ty0: store>(Arg0: u64, Arg1: u64, Arg2: &mut TxContext): BigVector<Ty0> {
B0:
LdConst[2](u64: 2)
CopyLoc[0](Arg0: u64)
Le
BrFalse(5)
B1:
Branch(9)
B2:
MoveLoc[2](Arg2: &mut TxContext)
Pop
LdConst[0](u64: 0)
Abort
B3:
CopyLoc[0](Arg0: u64)
LdConst[11](u64: 262144)
Le
BrFalse(14)
B4:
Branch(18)
B5:
MoveLoc[2](Arg2: &mut TxContext)
Pop
LdConst[1](u64: 1)
Abort
B6:
LdConst[4](u64: 4)
CopyLoc[1](Arg1: u64)
Le
BrFalse(23)
B7:
Branch(27)
B8:
MoveLoc[2](Arg2: &mut TxContext)
Pop
LdConst[2](u64: 2)
Abort
B9:
CopyLoc[1](Arg1: u64)
LdConst[10](u64: 4096)
Le
BrFalse(32)
B10:
Branch(36)
B11:
MoveLoc[2](Arg2: &mut TxContext)
Pop
LdConst[3](u64: 3)
Abort
B12:
MoveLoc[2](Arg2: &mut TxContext)
Call object::new(&mut TxContext): UID
LdU8(0)
LdU64(0)
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
LdConst[0](u64: 0)
LdConst[0](u64: 0)
PackGeneric[0](BigVector<Ty0>)
Ret
}
public(friend) destroy_empty<Ty0: store>(Arg0: BigVector<Ty0>) {
L1:	loc0: UID
L2:	loc1: u64
B0:
MoveLoc[0](Arg0: BigVector<Ty0>)
UnpackGeneric[0](BigVector<Ty0>)
Pop
Pop
Pop
Pop
StLoc[2](loc1: u64)
Pop
StLoc[1](loc0: UID)
MoveLoc[2](loc1: u64)
LdU64(0)
Eq
BrFalse(14)
B1:
Branch(16)
B2:
LdConst[4](u64: 4)
Abort
B3:
MoveLoc[1](loc0: UID)
Call object::delete(UID)
Ret
}
public(friend) is_empty<Ty0: store>(Arg0: &BigVector<Ty0>): bool {
B0:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[0](BigVector.length: u64)
ReadRef
LdU64(0)
Eq
Ret
}
public(friend) length<Ty0: store>(Arg0: &BigVector<Ty0>): u64 {
B0:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[0](BigVector.length: u64)
ReadRef
Ret
}
public(friend) depth<Ty0: store>(Arg0: &BigVector<Ty0>): u8 {
B0:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
Ret
}
public(friend) borrow<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: u128): &Ty0 {
L2:	loc0: u64
L3:	loc1: SliceRef
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
MoveLoc[1](Arg1: u128)
Call slice_around<Ty0>(&BigVector<Ty0>, u128): SliceRef * u64
StLoc[2](loc0: u64)
StLoc[3](loc1: SliceRef)
MoveLoc[0](Arg0: &BigVector<Ty0>)
MoveLoc[3](loc1: SliceRef)
Call borrow_slice<Ty0>(&BigVector<Ty0>, SliceRef): &Slice<Ty0>
MoveLoc[2](loc0: u64)
Call slice_borrow<Ty0>(&Slice<Ty0>, u64): &Ty0
Ret
}
public(friend) borrow_mut<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u128): &mut Ty0 {
L2:	loc0: u64
L3:	loc1: SliceRef
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
FreezeRef
MoveLoc[1](Arg1: u128)
Call slice_around<Ty0>(&BigVector<Ty0>, u128): SliceRef * u64
StLoc[2](loc0: u64)
StLoc[3](loc1: SliceRef)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[3](loc1: SliceRef)
Call borrow_slice_mut<Ty0>(&mut BigVector<Ty0>, SliceRef): &mut Slice<Ty0>
MoveLoc[2](loc0: u64)
Call slice_borrow_mut<Ty0>(&mut Slice<Ty0>, u64): &mut Ty0
Ret
}
public(friend) insert<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u128, Arg2: Ty0) {
L3:	loc0: u8
L4:	loc1: u128
L5:	loc2: u64
L6:	loc3: u64
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[0](BigVector.length: u64)
ReadRef
LdU64(1)
Add
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[0](BigVector.length: u64)
WriteRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(23)
B1:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u128)
MoveLoc[2](Arg2: Ty0)
Call singleton<Ty0>(u128, Ty0): Slice<Ty0>
Call alloc<Ty0, Ty0>(&mut BigVector<Ty0>, Slice<Ty0>): u64
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[2](BigVector.root_id: u64)
WriteRef
Ret
B2:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
StLoc[3](loc0: u8)
StLoc[6](loc3: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
CopyLoc[6](loc3: u64)
MoveLoc[3](loc0: u8)
MoveLoc[1](Arg1: u128)
MoveLoc[2](Arg2: Ty0)
Call slice_insert<Ty0>(&mut BigVector<Ty0>, u64, u8, u128, Ty0): u128 * u64
StLoc[5](loc2: u64)
StLoc[4](loc1: u128)
CopyLoc[5](loc2: u64)
LdConst[0](u64: 0)
Neq
BrFalse(61)
B3:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[4](loc1: u128)
MoveLoc[6](loc3: u64)
MoveLoc[5](loc2: u64)
Call branch(u128, u64, u64): Slice<u64>
Call alloc<Ty0, u64>(&mut BigVector<Ty0>, Slice<u64>): u64
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[2](BigVector.root_id: u64)
WriteRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
LdU8(1)
Add
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[1](BigVector.depth: u8)
WriteRef
Branch(63)
B4:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
B5:
Ret
}
public(friend) remove<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u128): Ty0 {
L2:	loc0: u8
L3:	loc1: u8
L4:	loc2: Slice<u64>
L5:	loc3: u64
L6:	loc4: Ty0
L7:	loc5: vector<Ty0>
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(10)
B1:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
LdConst[5](u64: 5)
Abort
B2:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[0](BigVector.length: u64)
ReadRef
LdU64(1)
Sub
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[0](BigVector.length: u64)
WriteRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
StLoc[2](loc0: u8)
StLoc[5](loc3: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
LdConst[0](u64: 0)
LdU128(0)
CopyLoc[5](loc3: u64)
LdU128(0)
LdConst[0](u64: 0)
MoveLoc[2](loc0: u8)
MoveLoc[1](Arg1: u128)
Call slice_remove<Ty0>(&mut BigVector<Ty0>, u64, u128, u64, u128, u64, u8, u128): Ty0 * u8 * u128
Pop
StLoc[3](loc1: u8)
StLoc[6](loc4: Ty0)
MoveLoc[3](loc1: u8)
LdConst[13](u8: 1)
Eq
BrFalse(84)
B3:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
LdU8(0)
Eq
BrFalse(64)
B4:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[5](loc3: u64)
Call dynamic_field::remove<u64, Slice<Ty0>>(&mut UID, u64): Slice<Ty0>
UnpackGeneric[1](Slice<Ty0>)
StLoc[7](loc5: vector<Ty0>)
Pop
Pop
Pop
MoveLoc[7](loc5: vector<Ty0>)
VecUnpack(12, 0)
LdConst[0](u64: 0)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[2](BigVector.root_id: u64)
WriteRef
Branch(86)
B5:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[5](loc3: u64)
Call dynamic_field::remove<u64, Slice<u64>>(&mut UID, u64): Slice<u64>
StLoc[4](loc2: Slice<u64>)
MutBorrowLoc[4](loc2: Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecPopBack(5)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[2](BigVector.root_id: u64)
WriteRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
LdU8(1)
Sub
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[1](BigVector.depth: u8)
WriteRef
Branch(86)
B6:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
B7:
MoveLoc[6](loc4: Ty0)
Ret
}
public(friend) remove_batch<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: vector<u128>): vector<Ty0> {
B0:
LdU64(0)
Abort
}
public(friend) slice_around<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: u128): SliceRef * u64 {
L2:	loc0: u64
L3:	loc1: &Slice<Ty0>
L4:	loc2: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(10)
B1:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
LdConst[5](u64: 5)
Abort
B2:
MoveLoc[0](Arg0: &BigVector<Ty0>)
CopyLoc[1](Arg1: u128)
Call find_leaf<Ty0>(&BigVector<Ty0>, u128): u64 * &Slice<Ty0> * u64
StLoc[4](loc2: u64)
StLoc[3](loc1: &Slice<Ty0>)
StLoc[2](loc0: u64)
CopyLoc[4](loc2: u64)
CopyLoc[3](loc1: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
Ge
BrFalse(26)
B3:
MoveLoc[3](loc1: &Slice<Ty0>)
Pop
LdConst[5](u64: 5)
Abort
B4:
MoveLoc[1](Arg1: u128)
MoveLoc[3](loc1: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[4](loc2: u64)
VecImmBorrow(24)
ReadRef
Neq
BrFalse(36)
B5:
LdConst[5](u64: 5)
Abort
B6:
MoveLoc[2](loc0: u64)
Pack[2](SliceRef)
MoveLoc[4](loc2: u64)
Ret
}
public(friend) slice_following<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: u128): SliceRef * u64 {
L2:	loc0: SliceRef
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: &Slice<Ty0>
L6:	loc4: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
LdConst[0](u64: 0)
Pack[2](SliceRef)
LdU64(0)
Ret
B2:
MoveLoc[0](Arg0: &BigVector<Ty0>)
MoveLoc[1](Arg1: u128)
Call find_leaf<Ty0>(&BigVector<Ty0>, u128): u64 * &Slice<Ty0> * u64
StLoc[6](loc4: u64)
StLoc[5](loc3: &Slice<Ty0>)
StLoc[4](loc2: u64)
CopyLoc[6](loc4: u64)
CopyLoc[5](loc3: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
Ge
BrFalse(30)
B3:
MoveLoc[5](loc3: &Slice<Ty0>)
Call slice_next<Ty0>(&Slice<Ty0>): SliceRef
LdU64(0)
StLoc[3](loc1: u64)
StLoc[2](loc0: SliceRef)
Branch(37)
B4:
MoveLoc[5](loc3: &Slice<Ty0>)
Pop
MoveLoc[4](loc2: u64)
Pack[2](SliceRef)
MoveLoc[6](loc4: u64)
StLoc[3](loc1: u64)
StLoc[2](loc0: SliceRef)
B5:
MoveLoc[2](loc0: SliceRef)
MoveLoc[3](loc1: u64)
Ret
}
public(friend) slice_before<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: u128): SliceRef * u64 {
L2:	loc0: SliceRef
L3:	loc1: u64
L4:	loc2: SliceRef
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: &Slice<Ty0>
L8:	loc6: u64
L9:	loc7: SliceRef
L10:	loc8: &Slice<Ty0>
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
LdConst[0](u64: 0)
Pack[2](SliceRef)
LdU64(0)
Ret
B2:
CopyLoc[0](Arg0: &BigVector<Ty0>)
MoveLoc[1](Arg1: u128)
Call find_leaf<Ty0>(&BigVector<Ty0>, u128): u64 * &Slice<Ty0> * u64
StLoc[8](loc6: u64)
StLoc[7](loc5: &Slice<Ty0>)
StLoc[6](loc4: u64)
CopyLoc[8](loc6: u64)
LdU64(0)
Eq
BrFalse(53)
B3:
MoveLoc[7](loc5: &Slice<Ty0>)
Call slice_prev<Ty0>(&Slice<Ty0>): SliceRef
StLoc[9](loc7: SliceRef)
ImmBorrowLoc[9](loc7: SliceRef)
Call slice_is_null(&SliceRef): bool
BrFalse(36)
B4:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
LdConst[0](u64: 0)
Pack[2](SliceRef)
LdU64(0)
StLoc[3](loc1: u64)
StLoc[2](loc0: SliceRef)
Branch(48)
B5:
MoveLoc[0](Arg0: &BigVector<Ty0>)
CopyLoc[9](loc7: SliceRef)
Call borrow_slice<Ty0>(&BigVector<Ty0>, SliceRef): &Slice<Ty0>
StLoc[10](loc8: &Slice<Ty0>)
MoveLoc[9](loc7: SliceRef)
MoveLoc[10](loc8: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
LdU64(1)
Sub
StLoc[3](loc1: u64)
StLoc[2](loc0: SliceRef)
B6:
MoveLoc[2](loc0: SliceRef)
MoveLoc[3](loc1: u64)
StLoc[5](loc3: u64)
StLoc[4](loc2: SliceRef)
Branch(64)
B7:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
MoveLoc[7](loc5: &Slice<Ty0>)
Pop
MoveLoc[6](loc4: u64)
Pack[2](SliceRef)
MoveLoc[8](loc6: u64)
LdU64(1)
Sub
StLoc[5](loc3: u64)
StLoc[4](loc2: SliceRef)
B8:
MoveLoc[4](loc2: SliceRef)
MoveLoc[5](loc3: u64)
Ret
}
public(friend) min_slice<Ty0: store>(Arg0: &BigVector<Ty0>): SliceRef * u64 {
L1:	loc0: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
LdConst[0](u64: 0)
Pack[2](SliceRef)
LdU64(0)
Ret
B2:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Call find_min_leaf<Ty0>(&BigVector<Ty0>): u64 * &Slice<Ty0> * u64
StLoc[1](loc0: u64)
Pop
Pack[2](SliceRef)
MoveLoc[1](loc0: u64)
Ret
}
public(friend) max_slice<Ty0: store>(Arg0: &BigVector<Ty0>): SliceRef * u64 {
L1:	loc0: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
LdConst[0](u64: 0)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
LdConst[0](u64: 0)
Pack[2](SliceRef)
LdU64(0)
Ret
B2:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Call find_max_leaf<Ty0>(&BigVector<Ty0>): u64 * &Slice<Ty0> * u64
StLoc[1](loc0: u64)
Pop
Pack[2](SliceRef)
MoveLoc[1](loc0: u64)
Ret
}
public(friend) next_slice<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: SliceRef, Arg2: u64): SliceRef * u64 {
L3:	loc0: SliceRef
L4:	loc1: u64
L5:	loc2: &Slice<Ty0>
B0:
MoveLoc[0](Arg0: &BigVector<Ty0>)
CopyLoc[1](Arg1: SliceRef)
Call borrow_slice<Ty0>(&BigVector<Ty0>, SliceRef): &Slice<Ty0>
StLoc[5](loc2: &Slice<Ty0>)
CopyLoc[2](Arg2: u64)
LdU64(1)
Add
CopyLoc[5](loc2: &Slice<Ty0>)
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
Lt
BrFalse(21)
B1:
MoveLoc[5](loc2: &Slice<Ty0>)
Pop
MoveLoc[1](Arg1: SliceRef)
MoveLoc[2](Arg2: u64)
LdU64(1)
Add
StLoc[4](loc1: u64)
StLoc[3](loc0: SliceRef)
Branch(26)
B2:
MoveLoc[5](loc2: &Slice<Ty0>)
Call slice_next<Ty0>(&Slice<Ty0>): SliceRef
LdU64(0)
StLoc[4](loc1: u64)
StLoc[3](loc0: SliceRef)
B3:
MoveLoc[3](loc0: SliceRef)
MoveLoc[4](loc1: u64)
Ret
}
public(friend) prev_slice<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: SliceRef, Arg2: u64): SliceRef * u64 {
L3:	loc0: SliceRef
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: SliceRef
L7:	loc4: &Slice<Ty0>
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
CopyLoc[1](Arg1: SliceRef)
Call borrow_slice<Ty0>(&BigVector<Ty0>, SliceRef): &Slice<Ty0>
StLoc[7](loc4: &Slice<Ty0>)
CopyLoc[2](Arg2: u64)
LdU64(0)
Gt
BrFalse(19)
B1:
MoveLoc[7](loc4: &Slice<Ty0>)
Pop
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
MoveLoc[1](Arg1: SliceRef)
MoveLoc[2](Arg2: u64)
LdU64(1)
Sub
StLoc[4](loc1: u64)
StLoc[3](loc0: SliceRef)
Branch(43)
B2:
LdU64(0)
StLoc[5](loc2: u64)
MoveLoc[7](loc4: &Slice<Ty0>)
Call slice_prev<Ty0>(&Slice<Ty0>): SliceRef
StLoc[6](loc3: SliceRef)
ImmBorrowLoc[6](loc3: SliceRef)
Call slice_is_null(&SliceRef): bool
Not
BrFalse(37)
B3:
MoveLoc[0](Arg0: &BigVector<Ty0>)
CopyLoc[6](loc3: SliceRef)
Call borrow_slice<Ty0>(&BigVector<Ty0>, SliceRef): &Slice<Ty0>
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
LdU64(1)
Sub
StLoc[5](loc2: u64)
Branch(39)
B4:
MoveLoc[0](Arg0: &BigVector<Ty0>)
Pop
B5:
MoveLoc[6](loc3: SliceRef)
MoveLoc[5](loc2: u64)
StLoc[4](loc1: u64)
StLoc[3](loc0: SliceRef)
B6:
MoveLoc[3](loc0: SliceRef)
MoveLoc[4](loc1: u64)
Ret
}
public(friend) borrow_slice<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: SliceRef): &Slice<Ty0> {
B0:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
ImmBorrowLoc[1](Arg1: SliceRef)
ImmBorrowField[6](SliceRef.ix: u64)
ReadRef
Call dynamic_field::borrow<u64, Slice<Ty0>>(&UID, u64): &Slice<Ty0>
Ret
}
public(friend) borrow_slice_mut<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: SliceRef): &mut Slice<Ty0> {
B0:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
ImmBorrowLoc[1](Arg1: SliceRef)
ImmBorrowField[6](SliceRef.ix: u64)
ReadRef
Call dynamic_field::borrow_mut<u64, Slice<Ty0>>(&mut UID, u64): &mut Slice<Ty0>
Ret
}
public(friend) slice_is_null(Arg0: &SliceRef): bool {
B0:
MoveLoc[0](Arg0: &SliceRef)
ImmBorrowField[6](SliceRef.ix: u64)
ReadRef
LdConst[0](u64: 0)
Eq
Ret
}
public(friend) slice_is_leaf<Ty0: store>(Arg0: &Slice<Ty0>): bool {
B0:
CopyLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
MoveLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
Eq
Ret
}
public(friend) slice_next<Ty0: store>(Arg0: &Slice<Ty0>): SliceRef {
B0:
MoveLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[7](Slice.next: u64)
ReadRef
Pack[2](SliceRef)
Ret
}
public(friend) slice_prev<Ty0: store>(Arg0: &Slice<Ty0>): SliceRef {
B0:
MoveLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[8](Slice.prev: u64)
ReadRef
Pack[2](SliceRef)
Ret
}
public(friend) slice_length<Ty0: store>(Arg0: &Slice<Ty0>): u64 {
B0:
MoveLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
Ret
}
public(friend) slice_key<Ty0: store>(Arg0: &Slice<Ty0>, Arg1: u64): u128 {
B0:
MoveLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
MoveLoc[1](Arg1: u64)
VecImmBorrow(24)
ReadRef
Ret
}
public(friend) slice_borrow<Ty0: store>(Arg0: &Slice<Ty0>, Arg1: u64): &Ty0 {
B0:
MoveLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
MoveLoc[1](Arg1: u64)
VecImmBorrow(12)
Ret
}
public(friend) slice_borrow_mut<Ty0: store>(Arg0: &mut Slice<Ty0>, Arg1: u64): &mut Ty0 {
B0:
MoveLoc[0](Arg0: &mut Slice<Ty0>)
MutBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
MoveLoc[1](Arg1: u64)
VecMutBorrow(12)
Ret
}
alloc<Ty0: store, Ty1: store>(Arg0: &mut BigVector<Ty0>, Arg1: Slice<Ty1>): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: &mut Slice<Ty1>
L5:	loc3: u64
L6:	loc4: &mut Slice<Ty1>
B0:
ImmBorrowLoc[1](Arg1: Slice<Ty1>)
ImmBorrowFieldGeneric[9](Slice.prev: u64)
ReadRef
StLoc[5](loc3: u64)
ImmBorrowLoc[1](Arg1: Slice<Ty1>)
ImmBorrowFieldGeneric[10](Slice.next: u64)
ReadRef
StLoc[3](loc1: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[11](BigVector.last_id: u64)
ReadRef
LdU64(1)
Add
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[11](BigVector.last_id: u64)
WriteRef
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[11](BigVector.last_id: u64)
ReadRef
MoveLoc[1](Arg1: Slice<Ty1>)
Call dynamic_field::add<u64, Slice<Ty1>>(&mut UID, u64, Slice<Ty1>)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[11](BigVector.last_id: u64)
ReadRef
StLoc[2](loc0: u64)
CopyLoc[5](loc3: u64)
LdConst[0](u64: 0)
Neq
BrFalse(40)
B1:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[5](loc3: u64)
Call dynamic_field::borrow_mut<u64, Slice<Ty1>>(&mut UID, u64): &mut Slice<Ty1>
StLoc[6](loc4: &mut Slice<Ty1>)
CopyLoc[2](loc0: u64)
MoveLoc[6](loc4: &mut Slice<Ty1>)
MutBorrowFieldGeneric[10](Slice.next: u64)
WriteRef
B2:
CopyLoc[3](loc1: u64)
LdConst[0](u64: 0)
Neq
BrFalse(54)
B3:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[3](loc1: u64)
Call dynamic_field::borrow_mut<u64, Slice<Ty1>>(&mut UID, u64): &mut Slice<Ty1>
StLoc[4](loc2: &mut Slice<Ty1>)
CopyLoc[2](loc0: u64)
MoveLoc[4](loc2: &mut Slice<Ty1>)
MutBorrowFieldGeneric[9](Slice.prev: u64)
WriteRef
Branch(56)
B4:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
B5:
MoveLoc[2](loc0: u64)
Ret
}
singleton<Ty0: store>(Arg0: u128, Arg1: Ty0): Slice<Ty0> {
B0:
LdConst[0](u64: 0)
LdConst[0](u64: 0)
MoveLoc[0](Arg0: u128)
VecPack(24, 1)
MoveLoc[1](Arg1: Ty0)
VecPack(12, 1)
PackGeneric[1](Slice<Ty0>)
Ret
}
branch(Arg0: u128, Arg1: u64, Arg2: u64): Slice<u64> {
B0:
LdConst[0](u64: 0)
LdConst[0](u64: 0)
MoveLoc[0](Arg0: u128)
VecPack(24, 1)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
VecPack(5, 2)
PackGeneric[2](Slice<u64>)
Ret
}
drop_slice<Ty0: drop + store>(Arg0: &mut UID, Arg1: u8, Arg2: u64) {
L3:	loc0: Slice<u64>
B0:
CopyLoc[2](Arg2: u64)
LdConst[0](u64: 0)
Eq
BrFalse(7)
B1:
MoveLoc[0](Arg0: &mut UID)
Pop
Ret
B2:
CopyLoc[1](Arg1: u8)
LdU8(0)
Eq
BrFalse(16)
B3:
MoveLoc[0](Arg0: &mut UID)
MoveLoc[2](Arg2: u64)
Call dynamic_field::remove<u64, Slice<Ty0>>(&mut UID, u64): Slice<Ty0>
Pop
Branch(37)
B4:
CopyLoc[0](Arg0: &mut UID)
MoveLoc[2](Arg2: u64)
Call dynamic_field::remove<u64, Slice<u64>>(&mut UID, u64): Slice<u64>
StLoc[3](loc0: Slice<u64>)
B5:
ImmBorrowLoc[3](loc0: Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
Call vector::is_empty<u64>(&vector<u64>): bool
Not
BrFalse(35)
B6:
Branch(26)
B7:
CopyLoc[0](Arg0: &mut UID)
CopyLoc[1](Arg1: u8)
LdU8(1)
Sub
MutBorrowLoc[3](loc0: Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecPopBack(5)
Call drop_slice<Ty0>(&mut UID, u8, u64)
Branch(20)
B8:
MoveLoc[0](Arg0: &mut UID)
Pop
B9:
Ret
}
find_leaf<Ty0: store>(Arg0: &BigVector<Ty0>, Arg1: u128): u64 * &Slice<Ty0> * u64 {
L2:	loc0: u8
L3:	loc1: &Slice<Ty0>
L4:	loc2: &Slice<u64>
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
StLoc[2](loc0: u8)
StLoc[7](loc5: u64)
B1:
CopyLoc[2](loc0: u8)
LdU8(0)
Gt
BrFalse(33)
B2:
Branch(13)
B3:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[7](loc5: u64)
Call dynamic_field::borrow<u64, Slice<u64>>(&UID, u64): &Slice<u64>
StLoc[4](loc2: &Slice<u64>)
CopyLoc[4](loc2: &Slice<u64>)
CopyLoc[1](Arg1: u128)
Call slice_bisect_right<u64>(&Slice<u64>, u128): u64
StLoc[5](loc3: u64)
MoveLoc[4](loc2: &Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[5](loc3: u64)
VecImmBorrow(5)
ReadRef
StLoc[7](loc5: u64)
MoveLoc[2](loc0: u8)
LdU8(1)
Sub
StLoc[2](loc0: u8)
Branch(8)
B4:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[7](loc5: u64)
Call dynamic_field::borrow<u64, Slice<Ty0>>(&UID, u64): &Slice<Ty0>
StLoc[3](loc1: &Slice<Ty0>)
CopyLoc[3](loc1: &Slice<Ty0>)
MoveLoc[1](Arg1: u128)
Call slice_bisect_left<Ty0>(&Slice<Ty0>, u128): u64
StLoc[6](loc4: u64)
MoveLoc[7](loc5: u64)
MoveLoc[3](loc1: &Slice<Ty0>)
MoveLoc[6](loc4: u64)
Ret
}
find_min_leaf<Ty0: store>(Arg0: &BigVector<Ty0>): u64 * &Slice<Ty0> * u64 {
L1:	loc0: u8
L2:	loc1: &Slice<Ty0>
L3:	loc2: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
StLoc[1](loc0: u8)
StLoc[3](loc2: u64)
B1:
CopyLoc[1](loc0: u8)
LdU8(0)
Gt
BrFalse(27)
B2:
Branch(13)
B3:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[3](loc2: u64)
Call dynamic_field::borrow<u64, Slice<u64>>(&UID, u64): &Slice<u64>
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
LdU64(0)
VecImmBorrow(5)
ReadRef
StLoc[3](loc2: u64)
MoveLoc[1](loc0: u8)
LdU8(1)
Sub
StLoc[1](loc0: u8)
Branch(8)
B4:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[3](loc2: u64)
Call dynamic_field::borrow<u64, Slice<Ty0>>(&UID, u64): &Slice<Ty0>
StLoc[2](loc1: &Slice<Ty0>)
MoveLoc[3](loc2: u64)
MoveLoc[2](loc1: &Slice<Ty0>)
LdU64(0)
Ret
}
find_max_leaf<Ty0: store>(Arg0: &BigVector<Ty0>): u64 * &Slice<Ty0> * u64 {
L1:	loc0: u8
L2:	loc1: &Slice<Ty0>
L3:	loc2: &Slice<u64>
L4:	loc3: u64
B0:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[2](BigVector.root_id: u64)
ReadRef
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[1](BigVector.depth: u8)
ReadRef
StLoc[1](loc0: u8)
StLoc[4](loc3: u64)
B1:
CopyLoc[1](loc0: u8)
LdU8(0)
Gt
BrFalse(31)
B2:
Branch(13)
B3:
CopyLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[4](loc3: u64)
Call dynamic_field::borrow<u64, Slice<u64>>(&UID, u64): &Slice<u64>
StLoc[3](loc2: &Slice<u64>)
CopyLoc[3](loc2: &Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[3](loc2: &Slice<u64>)
ImmBorrowFieldGeneric[12](Slice.keys: vector<u128>)
VecLen(24)
VecImmBorrow(5)
ReadRef
StLoc[4](loc3: u64)
MoveLoc[1](loc0: u8)
LdU8(1)
Sub
StLoc[1](loc0: u8)
Branch(8)
B4:
MoveLoc[0](Arg0: &BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[4](loc3: u64)
Call dynamic_field::borrow<u64, Slice<Ty0>>(&UID, u64): &Slice<Ty0>
StLoc[2](loc1: &Slice<Ty0>)
MoveLoc[4](loc3: u64)
CopyLoc[2](loc1: &Slice<Ty0>)
MoveLoc[2](loc1: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
LdU64(1)
Sub
Ret
}
slice_bisect_left<Ty0: store>(Arg0: &Slice<Ty0>, Arg1: u128): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
B0:
LdU64(0)
CopyLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
StLoc[2](loc0: u64)
StLoc[3](loc1: u64)
B1:
CopyLoc[3](loc1: u64)
CopyLoc[2](loc0: u64)
Lt
BrFalse(35)
B2:
Branch(11)
B3:
CopyLoc[2](loc0: u64)
CopyLoc[3](loc1: u64)
Sub
LdU64(2)
Div
CopyLoc[3](loc1: u64)
Add
StLoc[4](loc2: u64)
CopyLoc[1](Arg1: u128)
CopyLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[4](loc2: u64)
VecImmBorrow(24)
ReadRef
Le
BrFalse(30)
B4:
MoveLoc[4](loc2: u64)
StLoc[2](loc0: u64)
Branch(6)
B5:
MoveLoc[4](loc2: u64)
LdU64(1)
Add
StLoc[3](loc1: u64)
Branch(6)
B6:
MoveLoc[0](Arg0: &Slice<Ty0>)
Pop
MoveLoc[3](loc1: u64)
Ret
}
slice_bisect_right<Ty0: store>(Arg0: &Slice<Ty0>, Arg1: u128): u64 {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
B0:
LdU64(0)
CopyLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
StLoc[2](loc0: u64)
StLoc[3](loc1: u64)
B1:
CopyLoc[3](loc1: u64)
CopyLoc[2](loc0: u64)
Lt
BrFalse(35)
B2:
Branch(11)
B3:
CopyLoc[2](loc0: u64)
CopyLoc[3](loc1: u64)
Sub
LdU64(2)
Div
CopyLoc[3](loc1: u64)
Add
StLoc[4](loc2: u64)
CopyLoc[1](Arg1: u128)
CopyLoc[0](Arg0: &Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[4](loc2: u64)
VecImmBorrow(24)
ReadRef
Lt
BrFalse(30)
B4:
MoveLoc[4](loc2: u64)
StLoc[2](loc0: u64)
Branch(6)
B5:
MoveLoc[4](loc2: u64)
LdU64(1)
Add
StLoc[3](loc1: u64)
Branch(6)
B6:
MoveLoc[0](Arg0: &Slice<Ty0>)
Pop
MoveLoc[3](loc1: u64)
Ret
}
slice_insert<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u8, Arg3: u128, Arg4: Ty0): u128 * u64 {
L5:	loc0: u128
L6:	loc1: u64
B0:
CopyLoc[2](Arg2: u8)
LdU8(0)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: Ty0)
Call leaf_insert<Ty0>(&mut BigVector<Ty0>, u64, u128, Ty0): u128 * u64
StLoc[6](loc1: u64)
StLoc[5](loc0: u128)
Branch(22)
B2:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u8)
LdU8(1)
Sub
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: Ty0)
Call node_insert<Ty0>(&mut BigVector<Ty0>, u64, u8, u128, Ty0): u128 * u64
StLoc[6](loc1: u64)
StLoc[5](loc0: u128)
B3:
MoveLoc[5](loc0: u128)
MoveLoc[6](loc1: u64)
Ret
}
leaf_insert<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u128, Arg3: Ty0): u128 * u64 {
L4:	loc0: bool
L5:	loc1: &mut Slice<Ty0>
L6:	loc2: Slice<Ty0>
L7:	loc3: u64
L8:	loc4: u128
L9:	loc5: u64
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::borrow_mut<u64, Slice<Ty0>>(&mut UID, u64): &mut Slice<Ty0>
StLoc[5](loc1: &mut Slice<Ty0>)
CopyLoc[5](loc1: &mut Slice<Ty0>)
FreezeRef
CopyLoc[2](Arg2: u128)
Call slice_bisect_left<Ty0>(&Slice<Ty0>, u128): u64
StLoc[7](loc3: u64)
CopyLoc[7](loc3: u64)
CopyLoc[5](loc1: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
Lt
BrFalse(25)
B1:
CopyLoc[2](Arg2: u128)
CopyLoc[5](loc1: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[7](loc3: u64)
VecImmBorrow(24)
ReadRef
Eq
StLoc[4](loc0: bool)
Branch(27)
B2:
LdFalse
StLoc[4](loc0: bool)
B3:
MoveLoc[4](loc0: bool)
BrFalse(35)
B4:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[5](loc1: &mut Slice<Ty0>)
Pop
LdConst[6](u64: 6)
Abort
B5:
CopyLoc[5](loc1: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[13](BigVector.max_slice_size: u64)
ReadRef
Lt
BrFalse(58)
B6:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
CopyLoc[5](loc1: &mut Slice<Ty0>)
MutBorrowFieldGeneric[5](Slice.keys: vector<u128>)
MoveLoc[2](Arg2: u128)
CopyLoc[7](loc3: u64)
Call vector::insert<u128>(&mut vector<u128>, u128, u64)
MoveLoc[5](loc1: &mut Slice<Ty0>)
MutBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
MoveLoc[3](Arg3: Ty0)
MoveLoc[7](loc3: u64)
Call vector::insert<Ty0>(&mut vector<Ty0>, Ty0, u64)
LdU128(0)
LdConst[0](u64: 0)
Ret
B7:
CopyLoc[5](loc1: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
LdU64(2)
Div
StLoc[9](loc5: u64)
MoveLoc[1](Arg1: u64)
CopyLoc[5](loc1: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[7](Slice.next: u64)
ReadRef
CopyLoc[5](loc1: &mut Slice<Ty0>)
MutBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[9](loc5: u64)
Call utils::pop_until<u128>(&mut vector<u128>, u64): vector<u128>
CopyLoc[5](loc1: &mut Slice<Ty0>)
MutBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
CopyLoc[9](loc5: u64)
Call utils::pop_until<Ty0>(&mut vector<Ty0>, u64): vector<Ty0>
PackGeneric[1](Slice<Ty0>)
StLoc[6](loc2: Slice<Ty0>)
ImmBorrowLoc[6](loc2: Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
LdU64(0)
VecImmBorrow(24)
ReadRef
StLoc[8](loc4: u128)
CopyLoc[2](Arg2: u128)
CopyLoc[8](loc4: u128)
Lt
BrFalse(99)
B8:
CopyLoc[5](loc1: &mut Slice<Ty0>)
MutBorrowFieldGeneric[5](Slice.keys: vector<u128>)
MoveLoc[2](Arg2: u128)
CopyLoc[7](loc3: u64)
Call vector::insert<u128>(&mut vector<u128>, u128, u64)
MoveLoc[5](loc1: &mut Slice<Ty0>)
MutBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
MoveLoc[3](Arg3: Ty0)
MoveLoc[7](loc3: u64)
Call vector::insert<Ty0>(&mut vector<Ty0>, Ty0, u64)
Branch(115)
B9:
MoveLoc[5](loc1: &mut Slice<Ty0>)
Pop
MutBorrowLoc[6](loc2: Slice<Ty0>)
MutBorrowFieldGeneric[5](Slice.keys: vector<u128>)
MoveLoc[2](Arg2: u128)
CopyLoc[7](loc3: u64)
CopyLoc[9](loc5: u64)
Sub
Call vector::insert<u128>(&mut vector<u128>, u128, u64)
MutBorrowLoc[6](loc2: Slice<Ty0>)
MutBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
MoveLoc[3](Arg3: Ty0)
MoveLoc[7](loc3: u64)
MoveLoc[9](loc5: u64)
Sub
Call vector::insert<Ty0>(&mut vector<Ty0>, Ty0, u64)
B10:
MoveLoc[8](loc4: u128)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[6](loc2: Slice<Ty0>)
Call alloc<Ty0, Ty0>(&mut BigVector<Ty0>, Slice<Ty0>): u64
Ret
}
node_insert<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u8, Arg3: u128, Arg4: Ty0): u128 * u64 {
L5:	loc0: u64
L6:	loc1: u128
L7:	loc2: Slice<u64>
L8:	loc3: &mut Slice<u64>
L9:	loc4: &mut Slice<u64>
L10:	loc5: u64
L11:	loc6: u128
L12:	loc7: u64
L13:	loc8: u64
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::borrow_mut<u64, Slice<u64>>(&mut UID, u64): &mut Slice<u64>
StLoc[8](loc3: &mut Slice<u64>)
CopyLoc[8](loc3: &mut Slice<u64>)
FreezeRef
CopyLoc[3](Arg3: u128)
Call slice_bisect_right<u64>(&Slice<u64>, u128): u64
StLoc[10](loc5: u64)
MoveLoc[8](loc3: &mut Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
CopyLoc[10](loc5: u64)
VecImmBorrow(5)
ReadRef
StLoc[5](loc0: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[5](loc0: u64)
MoveLoc[2](Arg2: u8)
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: Ty0)
Call slice_insert<Ty0>(&mut BigVector<Ty0>, u64, u8, u128, Ty0): u128 * u64
StLoc[13](loc8: u64)
StLoc[6](loc1: u128)
CopyLoc[13](loc8: u64)
LdConst[0](u64: 0)
Eq
BrFalse(33)
B1:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
LdU128(0)
LdConst[0](u64: 0)
Ret
B2:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::borrow_mut<u64, Slice<u64>>(&mut UID, u64): &mut Slice<u64>
StLoc[9](loc4: &mut Slice<u64>)
CopyLoc[9](loc4: &mut Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecLen(5)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[14](BigVector.max_fan_out: u64)
ReadRef
Lt
BrFalse(63)
B3:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
CopyLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
MoveLoc[6](loc1: u128)
CopyLoc[10](loc5: u64)
Call vector::insert<u128>(&mut vector<u128>, u128, u64)
MoveLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[13](loc8: u64)
MoveLoc[10](loc5: u64)
LdU64(1)
Add
Call vector::insert<u64>(&mut vector<u64>, u64, u64)
LdU128(0)
LdConst[0](u64: 0)
Ret
B4:
CopyLoc[9](loc4: &mut Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecLen(5)
LdU64(2)
Div
StLoc[12](loc7: u64)
MoveLoc[1](Arg1: u64)
CopyLoc[9](loc4: &mut Slice<u64>)
ImmBorrowFieldGeneric[15](Slice.next: u64)
ReadRef
CopyLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
CopyLoc[12](loc7: u64)
Call utils::pop_until<u128>(&mut vector<u128>, u64): vector<u128>
CopyLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
CopyLoc[12](loc7: u64)
Call utils::pop_until<u64>(&mut vector<u64>, u64): vector<u64>
PackGeneric[2](Slice<u64>)
StLoc[7](loc2: Slice<u64>)
CopyLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
VecPopBack(24)
StLoc[11](loc6: u128)
CopyLoc[6](loc1: u128)
CopyLoc[11](loc6: u128)
Lt
BrFalse(104)
B5:
CopyLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
MoveLoc[6](loc1: u128)
CopyLoc[10](loc5: u64)
Call vector::insert<u128>(&mut vector<u128>, u128, u64)
MoveLoc[9](loc4: &mut Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[13](loc8: u64)
MoveLoc[10](loc5: u64)
LdU64(1)
Add
Call vector::insert<u64>(&mut vector<u64>, u64, u64)
Branch(122)
B6:
MoveLoc[9](loc4: &mut Slice<u64>)
Pop
MutBorrowLoc[7](loc2: Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
MoveLoc[6](loc1: u128)
CopyLoc[10](loc5: u64)
CopyLoc[12](loc7: u64)
Sub
Call vector::insert<u128>(&mut vector<u128>, u128, u64)
MutBorrowLoc[7](loc2: Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[13](loc8: u64)
MoveLoc[10](loc5: u64)
MoveLoc[12](loc7: u64)
Sub
LdU64(1)
Add
Call vector::insert<u64>(&mut vector<u64>, u64, u64)
B7:
MoveLoc[11](loc6: u128)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[7](loc2: Slice<u64>)
Call alloc<Ty0, u64>(&mut BigVector<Ty0>, Slice<u64>): u64
Ret
}
slice_remove<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u128, Arg3: u64, Arg4: u128, Arg5: u64, Arg6: u8, Arg7: u128): Ty0 * u8 * u128 {
L8:	loc0: Ty0
L9:	loc1: u8
L10:	loc2: u128
B0:
CopyLoc[6](Arg6: u8)
LdU8(0)
Eq
BrFalse(16)
B1:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: u64)
MoveLoc[7](Arg7: u128)
Call leaf_remove<Ty0>(&mut BigVector<Ty0>, u64, u128, u64, u128, u64, u128): Ty0 * u8 * u128
StLoc[10](loc2: u128)
StLoc[9](loc1: u8)
StLoc[8](loc0: Ty0)
Branch(30)
B2:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: u64)
MoveLoc[6](Arg6: u8)
LdU8(1)
Sub
MoveLoc[7](Arg7: u128)
Call node_remove<Ty0>(&mut BigVector<Ty0>, u64, u128, u64, u128, u64, u8, u128): Ty0 * u8 * u128
StLoc[10](loc2: u128)
StLoc[9](loc1: u8)
StLoc[8](loc0: Ty0)
B3:
MoveLoc[8](loc0: Ty0)
MoveLoc[9](loc1: u8)
MoveLoc[10](loc2: u128)
Ret
}
leaf_remove<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u128, Arg3: u64, Arg4: u128, Arg5: u64, Arg6: u128): Ty0 * u8 * u128 {
L7:	loc0: Ty0
L8:	loc1: u8
L9:	loc2: u128
L10:	loc3: &mut Slice<Ty0>
L11:	loc4: u64
L12:	loc5: u64
L13:	loc6: u64
L14:	loc7: Ty0
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[3](Arg3: u64)
Call dynamic_field::borrow_mut<u64, Slice<Ty0>>(&mut UID, u64): &mut Slice<Ty0>
StLoc[10](loc3: &mut Slice<Ty0>)
CopyLoc[10](loc3: &mut Slice<Ty0>)
FreezeRef
CopyLoc[6](Arg6: u128)
Call slice_bisect_left<Ty0>(&Slice<Ty0>, u128): u64
StLoc[12](loc5: u64)
CopyLoc[12](loc5: u64)
CopyLoc[10](loc3: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
VecLen(24)
Ge
BrFalse(22)
B1:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[10](loc3: &mut Slice<Ty0>)
Pop
LdConst[5](u64: 5)
Abort
B2:
MoveLoc[6](Arg6: u128)
CopyLoc[10](loc3: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[12](loc5: u64)
VecImmBorrow(24)
ReadRef
Neq
BrFalse(36)
B3:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[10](loc3: &mut Slice<Ty0>)
Pop
LdConst[5](u64: 5)
Abort
B4:
CopyLoc[10](loc3: &mut Slice<Ty0>)
MutBorrowFieldGeneric[5](Slice.keys: vector<u128>)
CopyLoc[12](loc5: u64)
Call vector::remove<u128>(&mut vector<u128>, u64): u128
Pop
CopyLoc[10](loc3: &mut Slice<Ty0>)
MutBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
MoveLoc[12](loc5: u64)
Call vector::remove<Ty0>(&mut vector<Ty0>, u64): Ty0
StLoc[14](loc7: Ty0)
MoveLoc[10](loc3: &mut Slice<Ty0>)
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
StLoc[13](loc6: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[13](BigVector.max_slice_size: u64)
ReadRef
LdU64(2)
Div
StLoc[11](loc4: u64)
CopyLoc[13](loc6: u64)
CopyLoc[11](loc4: u64)
Ge
BrFalse(66)
B5:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[14](loc7: Ty0)
LdConst[12](u8: 0)
LdU128(0)
Ret
B6:
CopyLoc[1](Arg1: u64)
LdConst[0](u64: 0)
Neq
BrFalse(87)
B7:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::borrow<u64, Slice<Ty0>>(&UID, u64): &Slice<Ty0>
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
CopyLoc[11](loc4: u64)
Gt
BrFalse(87)
B8:
MoveLoc[14](loc7: Ty0)
LdConst[14](u8: 2)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
Call slice_redistribute<Ty0, Ty0>(&mut BigVector<Ty0>, u64, u128, u64): u128
Ret
B9:
CopyLoc[5](Arg5: u64)
LdConst[0](u64: 0)
Neq
BrFalse(108)
B10:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[5](Arg5: u64)
Call dynamic_field::borrow<u64, Slice<Ty0>>(&UID, u64): &Slice<Ty0>
ImmBorrowFieldGeneric[6](Slice.vals: vector<Ty0>)
VecLen(12)
MoveLoc[11](loc4: u64)
Gt
BrFalse(108)
B11:
MoveLoc[14](loc7: Ty0)
LdConst[15](u8: 3)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: u64)
Call slice_redistribute<Ty0, Ty0>(&mut BigVector<Ty0>, u64, u128, u64): u128
Ret
B12:
CopyLoc[1](Arg1: u64)
LdConst[0](u64: 0)
Neq
BrFalse(121)
B13:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
Call slice_merge<Ty0, Ty0>(&mut BigVector<Ty0>, u64, u128, u64)
MoveLoc[14](loc7: Ty0)
LdConst[16](u8: 4)
LdU128(0)
Ret
B14:
CopyLoc[5](Arg5: u64)
LdConst[0](u64: 0)
Neq
BrFalse(134)
B15:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: u64)
Call slice_merge<Ty0, Ty0>(&mut BigVector<Ty0>, u64, u128, u64)
MoveLoc[14](loc7: Ty0)
LdConst[17](u8: 5)
LdU128(0)
Ret
B16:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[13](loc6: u64)
LdU64(0)
Eq
BrFalse(147)
B17:
MoveLoc[14](loc7: Ty0)
LdConst[13](u8: 1)
LdU128(0)
StLoc[9](loc2: u128)
StLoc[8](loc1: u8)
StLoc[7](loc0: Ty0)
Branch(153)
B18:
MoveLoc[14](loc7: Ty0)
LdConst[12](u8: 0)
LdU128(0)
StLoc[9](loc2: u128)
StLoc[8](loc1: u8)
StLoc[7](loc0: Ty0)
B19:
MoveLoc[7](loc0: Ty0)
MoveLoc[8](loc1: u8)
MoveLoc[9](loc2: u128)
Ret
}
node_remove<Ty0: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u128, Arg3: u64, Arg4: u128, Arg5: u64, Arg6: u8, Arg7: u128): Ty0 * u8 * u128 {
L8:	loc0: u64
L9:	loc1: u128
L10:	loc2: u64
L11:	loc3: u128
L12:	loc4: Ty0
L13:	loc5: u8
L14:	loc6: u128
L15:	loc7: u64
L16:	loc8: u64
L17:	loc9: u128
L18:	loc10: u64
L19:	loc11: u128
L20:	loc12: u64
L21:	loc13: &Slice<u64>
L22:	loc14: &mut Slice<u64>
L23:	loc15: u64
L24:	loc16: u128
L25:	loc17: u64
L26:	loc18: u8
L27:	loc19: Ty0
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[3](Arg3: u64)
Call dynamic_field::borrow<u64, Slice<u64>>(&UID, u64): &Slice<u64>
StLoc[21](loc13: &Slice<u64>)
CopyLoc[21](loc13: &Slice<u64>)
CopyLoc[7](Arg7: u128)
Call slice_bisect_right<u64>(&Slice<u64>, u128): u64
StLoc[23](loc15: u64)
CopyLoc[21](loc13: &Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
CopyLoc[23](loc15: u64)
VecImmBorrow(5)
ReadRef
StLoc[15](loc7: u64)
CopyLoc[23](loc15: u64)
LdU64(0)
Eq
BrFalse(24)
B1:
LdConst[0](u64: 0)
LdU128(0)
StLoc[9](loc1: u128)
StLoc[8](loc0: u64)
Branch(40)
B2:
CopyLoc[21](loc13: &Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
CopyLoc[23](loc15: u64)
LdU64(1)
Sub
VecImmBorrow(5)
ReadRef
CopyLoc[21](loc13: &Slice<u64>)
ImmBorrowFieldGeneric[12](Slice.keys: vector<u128>)
CopyLoc[23](loc15: u64)
LdU64(1)
Sub
VecImmBorrow(24)
ReadRef
StLoc[9](loc1: u128)
StLoc[8](loc0: u64)
B3:
MoveLoc[8](loc0: u64)
MoveLoc[9](loc1: u128)
StLoc[19](loc11: u128)
StLoc[18](loc10: u64)
CopyLoc[23](loc15: u64)
CopyLoc[21](loc13: &Slice<u64>)
ImmBorrowFieldGeneric[12](Slice.keys: vector<u128>)
VecLen(24)
Eq
BrFalse(57)
B4:
MoveLoc[21](loc13: &Slice<u64>)
Pop
LdConst[0](u64: 0)
LdU128(0)
StLoc[11](loc3: u128)
StLoc[10](loc2: u64)
Branch(71)
B5:
CopyLoc[21](loc13: &Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
CopyLoc[23](loc15: u64)
LdU64(1)
Add
VecImmBorrow(5)
ReadRef
MoveLoc[21](loc13: &Slice<u64>)
ImmBorrowFieldGeneric[12](Slice.keys: vector<u128>)
CopyLoc[23](loc15: u64)
VecImmBorrow(24)
ReadRef
StLoc[11](loc3: u128)
StLoc[10](loc2: u64)
B6:
MoveLoc[10](loc2: u64)
MoveLoc[11](loc3: u128)
StLoc[17](loc9: u128)
StLoc[16](loc8: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[18](loc10: u64)
MoveLoc[19](loc11: u128)
MoveLoc[15](loc7: u64)
MoveLoc[17](loc9: u128)
MoveLoc[16](loc8: u64)
MoveLoc[6](Arg6: u8)
MoveLoc[7](Arg7: u128)
Call slice_remove<Ty0>(&mut BigVector<Ty0>, u64, u128, u64, u128, u64, u8, u128): Ty0 * u8 * u128
StLoc[24](loc16: u128)
StLoc[26](loc18: u8)
StLoc[27](loc19: Ty0)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[3](Arg3: u64)
Call dynamic_field::borrow_mut<u64, Slice<u64>>(&mut UID, u64): &mut Slice<u64>
StLoc[22](loc14: &mut Slice<u64>)
CopyLoc[26](loc18: u8)
LdConst[12](u8: 0)
Eq
BrFalse(104)
B7:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[22](loc14: &mut Slice<u64>)
Pop
MoveLoc[27](loc19: Ty0)
LdConst[12](u8: 0)
LdU128(0)
Ret
B8:
CopyLoc[26](loc18: u8)
LdConst[14](u8: 2)
Eq
BrFalse(122)
B9:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[24](loc16: u128)
MoveLoc[22](loc14: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
MoveLoc[23](loc15: u64)
LdU64(1)
Sub
VecMutBorrow(24)
WriteRef
MoveLoc[27](loc19: Ty0)
LdConst[12](u8: 0)
LdU128(0)
Ret
B10:
CopyLoc[26](loc18: u8)
LdConst[15](u8: 3)
Eq
BrFalse(138)
B11:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[24](loc16: u128)
MoveLoc[22](loc14: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
MoveLoc[23](loc15: u64)
VecMutBorrow(24)
WriteRef
MoveLoc[27](loc19: Ty0)
LdConst[12](u8: 0)
LdU128(0)
Ret
B12:
CopyLoc[26](loc18: u8)
LdConst[16](u8: 4)
Eq
BrFalse(155)
B13:
CopyLoc[22](loc14: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
CopyLoc[23](loc15: u64)
LdU64(1)
Sub
Call vector::remove<u128>(&mut vector<u128>, u64): u128
Pop
CopyLoc[22](loc14: &mut Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[23](loc15: u64)
Call vector::remove<u64>(&mut vector<u64>, u64): u64
Pop
Branch(178)
B14:
MoveLoc[26](loc18: u8)
LdConst[17](u8: 5)
Eq
BrFalse(172)
B15:
CopyLoc[22](loc14: &mut Slice<u64>)
MutBorrowFieldGeneric[12](Slice.keys: vector<u128>)
CopyLoc[23](loc15: u64)
Call vector::remove<u128>(&mut vector<u128>, u64): u128
Pop
CopyLoc[22](loc14: &mut Slice<u64>)
MutBorrowFieldGeneric[4](Slice.vals: vector<u64>)
MoveLoc[23](loc15: u64)
LdU64(1)
Add
Call vector::remove<u64>(&mut vector<u64>, u64): u64
Pop
Branch(178)
B16:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[22](loc14: &mut Slice<u64>)
Pop
LdConst[7](u64: 7)
Abort
B17:
MoveLoc[22](loc14: &mut Slice<u64>)
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecLen(5)
StLoc[25](loc17: u64)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[14](BigVector.max_fan_out: u64)
ReadRef
LdU64(2)
Div
StLoc[20](loc12: u64)
CopyLoc[25](loc17: u64)
CopyLoc[20](loc12: u64)
Ge
BrFalse(198)
B18:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[27](loc19: Ty0)
LdConst[12](u8: 0)
LdU128(0)
Ret
B19:
CopyLoc[1](Arg1: u64)
LdConst[0](u64: 0)
Neq
BrFalse(219)
B20:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::borrow<u64, Slice<u64>>(&UID, u64): &Slice<u64>
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecLen(5)
CopyLoc[20](loc12: u64)
Gt
BrFalse(219)
B21:
MoveLoc[27](loc19: Ty0)
LdConst[14](u8: 2)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
Call slice_redistribute<Ty0, u64>(&mut BigVector<Ty0>, u64, u128, u64): u128
Ret
B22:
CopyLoc[5](Arg5: u64)
LdConst[0](u64: 0)
Neq
BrFalse(240)
B23:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
ImmBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[5](Arg5: u64)
Call dynamic_field::borrow<u64, Slice<u64>>(&UID, u64): &Slice<u64>
ImmBorrowFieldGeneric[4](Slice.vals: vector<u64>)
VecLen(5)
MoveLoc[20](loc12: u64)
Gt
BrFalse(240)
B24:
MoveLoc[27](loc19: Ty0)
LdConst[15](u8: 3)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: u64)
Call slice_redistribute<Ty0, u64>(&mut BigVector<Ty0>, u64, u128, u64): u128
Ret
B25:
CopyLoc[1](Arg1: u64)
LdConst[0](u64: 0)
Neq
BrFalse(253)
B26:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
Call slice_merge<Ty0, u64>(&mut BigVector<Ty0>, u64, u128, u64)
MoveLoc[27](loc19: Ty0)
LdConst[16](u8: 4)
LdU128(0)
Ret
B27:
CopyLoc[5](Arg5: u64)
LdConst[0](u64: 0)
Neq
BrFalse(266)
B28:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u128)
MoveLoc[5](Arg5: u64)
Call slice_merge<Ty0, u64>(&mut BigVector<Ty0>, u64, u128, u64)
MoveLoc[27](loc19: Ty0)
LdConst[17](u8: 5)
LdU128(0)
Ret
B29:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
CopyLoc[25](loc17: u64)
LdU64(0)
Eq
BrFalse(274)
B30:
LdConst[7](u64: 7)
Abort
B31:
MoveLoc[25](loc17: u64)
LdU64(1)
Eq
BrFalse(285)
B32:
MoveLoc[27](loc19: Ty0)
LdConst[13](u8: 1)
LdU128(0)
StLoc[14](loc6: u128)
StLoc[13](loc5: u8)
StLoc[12](loc4: Ty0)
Branch(291)
B33:
MoveLoc[27](loc19: Ty0)
LdConst[12](u8: 0)
LdU128(0)
StLoc[14](loc6: u128)
StLoc[13](loc5: u8)
StLoc[12](loc4: Ty0)
B34:
MoveLoc[12](loc4: Ty0)
MoveLoc[13](loc5: u8)
MoveLoc[14](loc6: u128)
Ret
}
slice_redistribute<Ty0: store, Ty1: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u128, Arg3: u64): u128 {
L4:	loc0: vector<u128>
L5:	loc1: vector<u128>
L6:	loc2: u128
L7:	loc3: vector<u128>
L8:	loc4: vector<u128>
L9:	loc5: u128
L10:	loc6: vector<u128>
L11:	loc7: bool
L12:	loc8: vector<Ty1>
L13:	loc9: vector<Ty1>
L14:	loc10: bool
L15:	loc11: bool
L16:	loc12: bool
L17:	loc13: vector<u128>
L18:	loc14: u128
L19:	loc15: bool
L20:	loc16: Slice<Ty1>
L21:	loc17: bool
L22:	loc18: vector<u128>
L23:	loc19: vector<u128>
L24:	loc20: u64
L25:	loc21: u64
L26:	loc22: vector<Ty1>
L27:	loc23: vector<Ty1>
L28:	loc24: vector<u128>
L29:	loc25: vector<u128>
L30:	loc26: vector<u128>
L31:	loc27: vector<u128>
L32:	loc28: vector<Ty1>
L33:	loc29: vector<Ty1>
L34:	loc30: u64
L35:	loc31: u64
L36:	loc32: u64
L37:	loc33: u64
L38:	loc34: u128
L39:	loc35: u128
L40:	loc36: u128
L41:	loc37: u128
L42:	loc38: u128
L43:	loc39: Slice<Ty1>
L44:	loc40: vector<u128>
L45:	loc41: vector<u128>
L46:	loc42: vector<u128>
L47:	loc43: vector<u128>
L48:	loc44: u64
L49:	loc45: u64
L50:	loc46: vector<Ty1>
L51:	loc47: vector<Ty1>
L52:	loc48: vector<Ty1>
L53:	loc49: u64
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::remove<u64, Slice<Ty1>>(&mut UID, u64): Slice<Ty1>
StLoc[20](loc16: Slice<Ty1>)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[3](Arg3: u64)
Call dynamic_field::remove<u64, Slice<Ty1>>(&mut UID, u64): Slice<Ty1>
StLoc[43](loc39: Slice<Ty1>)
ImmBorrowLoc[20](loc16: Slice<Ty1>)
ImmBorrowFieldGeneric[10](Slice.next: u64)
ReadRef
CopyLoc[3](Arg3: u64)
Eq
BrFalse(17)
B1:
Branch(21)
B2:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
LdConst[8](u64: 8)
Abort
B3:
ImmBorrowLoc[43](loc39: Slice<Ty1>)
ImmBorrowFieldGeneric[9](Slice.prev: u64)
ReadRef
CopyLoc[1](Arg1: u64)
Eq
BrFalse(28)
B4:
Branch(32)
B5:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
LdConst[8](u64: 8)
Abort
B6:
ImmBorrowLoc[20](loc16: Slice<Ty1>)
Call slice_is_leaf<Ty1>(&Slice<Ty1>): bool
StLoc[19](loc15: bool)
MoveLoc[20](loc16: Slice<Ty1>)
UnpackGeneric[3](Slice<Ty1>)
StLoc[26](loc22: vector<Ty1>)
StLoc[22](loc18: vector<u128>)
StLoc[24](loc20: u64)
StLoc[25](loc21: u64)
MoveLoc[43](loc39: Slice<Ty1>)
UnpackGeneric[3](Slice<Ty1>)
StLoc[50](loc46: vector<Ty1>)
StLoc[44](loc40: vector<u128>)
StLoc[48](loc44: u64)
StLoc[49](loc45: u64)
ImmBorrowLoc[26](loc22: vector<Ty1>)
VecLen(51)
StLoc[36](loc32: u64)
ImmBorrowLoc[50](loc46: vector<Ty1>)
VecLen(51)
StLoc[37](loc33: u64)
CopyLoc[36](loc32: u64)
CopyLoc[37](loc33: u64)
Add
StLoc[53](loc49: u64)
CopyLoc[53](loc49: u64)
LdU64(2)
Div
StLoc[34](loc30: u64)
MoveLoc[53](loc49: u64)
CopyLoc[34](loc30: u64)
Sub
StLoc[35](loc31: u64)
CopyLoc[34](loc30: u64)
MoveLoc[36](loc32: u64)
Lt
BrFalse(72)
B7:
LdTrue
StLoc[11](loc7: bool)
Branch(83)
B8:
CopyLoc[35](loc31: u64)
MoveLoc[37](loc33: u64)
Lt
BrFalse(77)
B9:
Branch(81)
B10:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
LdConst[9](u64: 9)
Abort
B11:
LdFalse
StLoc[11](loc7: bool)
B12:
MoveLoc[11](loc7: bool)
StLoc[21](loc17: bool)
CopyLoc[21](loc17: bool)
BrFalse(99)
B13:
MutBorrowLoc[26](loc22: vector<Ty1>)
CopyLoc[34](loc30: u64)
Call utils::pop_until<Ty1>(&mut vector<Ty1>, u64): vector<Ty1>
StLoc[32](loc28: vector<Ty1>)
MutBorrowLoc[32](loc28: vector<Ty1>)
MoveLoc[50](loc46: vector<Ty1>)
Call vector::append<Ty1>(&mut vector<Ty1>, vector<Ty1>)
MoveLoc[26](loc22: vector<Ty1>)
MoveLoc[32](loc28: vector<Ty1>)
StLoc[13](loc9: vector<Ty1>)
StLoc[12](loc8: vector<Ty1>)
Branch(112)
B14:
MoveLoc[50](loc46: vector<Ty1>)
StLoc[33](loc29: vector<Ty1>)
MutBorrowLoc[33](loc29: vector<Ty1>)
CopyLoc[35](loc31: u64)
Call utils::pop_n<Ty1>(&mut vector<Ty1>, u64): vector<Ty1>
StLoc[51](loc47: vector<Ty1>)
MutBorrowLoc[26](loc22: vector<Ty1>)
MoveLoc[33](loc29: vector<Ty1>)
Call vector::append<Ty1>(&mut vector<Ty1>, vector<Ty1>)
MoveLoc[26](loc22: vector<Ty1>)
MoveLoc[51](loc47: vector<Ty1>)
StLoc[13](loc9: vector<Ty1>)
StLoc[12](loc8: vector<Ty1>)
B15:
MoveLoc[12](loc8: vector<Ty1>)
MoveLoc[13](loc9: vector<Ty1>)
StLoc[52](loc48: vector<Ty1>)
StLoc[27](loc23: vector<Ty1>)
CopyLoc[19](loc15: bool)
BrFalse(121)
B16:
CopyLoc[21](loc17: bool)
StLoc[14](loc10: bool)
Branch(123)
B17:
LdFalse
StLoc[14](loc10: bool)
B18:
MoveLoc[14](loc10: bool)
BrFalse(144)
B19:
MutBorrowLoc[22](loc18: vector<u128>)
MoveLoc[34](loc30: u64)
Call utils::pop_until<u128>(&mut vector<u128>, u64): vector<u128>
StLoc[28](loc24: vector<u128>)
ImmBorrowLoc[28](loc24: vector<u128>)
LdU64(0)
VecImmBorrow(24)
ReadRef
StLoc[38](loc34: u128)
MutBorrowLoc[28](loc24: vector<u128>)
MoveLoc[44](loc40: vector<u128>)
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MoveLoc[22](loc18: vector<u128>)
MoveLoc[38](loc34: u128)
MoveLoc[28](loc24: vector<u128>)
StLoc[10](loc6: vector<u128>)
StLoc[9](loc5: u128)
StLoc[8](loc4: vector<u128>)
Branch(240)
B20:
CopyLoc[19](loc15: bool)
BrFalse(150)
B21:
CopyLoc[21](loc17: bool)
Not
StLoc[15](loc11: bool)
Branch(152)
B22:
LdFalse
StLoc[15](loc11: bool)
B23:
MoveLoc[15](loc11: bool)
BrFalse(175)
B24:
MoveLoc[44](loc40: vector<u128>)
StLoc[29](loc25: vector<u128>)
MutBorrowLoc[29](loc25: vector<u128>)
MoveLoc[35](loc31: u64)
Call utils::pop_n<u128>(&mut vector<u128>, u64): vector<u128>
StLoc[45](loc41: vector<u128>)
ImmBorrowLoc[45](loc41: vector<u128>)
LdU64(0)
VecImmBorrow(24)
ReadRef
StLoc[39](loc35: u128)
MutBorrowLoc[22](loc18: vector<u128>)
MoveLoc[29](loc25: vector<u128>)
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MoveLoc[22](loc18: vector<u128>)
MoveLoc[39](loc35: u128)
MoveLoc[45](loc41: vector<u128>)
StLoc[7](loc3: vector<u128>)
StLoc[6](loc2: u128)
StLoc[5](loc1: vector<u128>)
Branch(234)
B25:
MoveLoc[19](loc15: bool)
Not
BrFalse(181)
B26:
MoveLoc[21](loc17: bool)
StLoc[16](loc12: bool)
Branch(183)
B27:
LdFalse
StLoc[16](loc12: bool)
B28:
MoveLoc[16](loc12: bool)
BrFalse(205)
B29:
MutBorrowLoc[22](loc18: vector<u128>)
MoveLoc[34](loc30: u64)
Call utils::pop_until<u128>(&mut vector<u128>, u64): vector<u128>
StLoc[30](loc26: vector<u128>)
MutBorrowLoc[30](loc26: vector<u128>)
MoveLoc[2](Arg2: u128)
VecPushBack(24)
MutBorrowLoc[30](loc26: vector<u128>)
MoveLoc[44](loc40: vector<u128>)
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MutBorrowLoc[22](loc18: vector<u128>)
VecPopBack(24)
StLoc[40](loc36: u128)
MoveLoc[22](loc18: vector<u128>)
MoveLoc[40](loc36: u128)
MoveLoc[30](loc26: vector<u128>)
StLoc[4](loc0: vector<u128>)
StLoc[18](loc14: u128)
StLoc[17](loc13: vector<u128>)
Branch(228)
B30:
MutBorrowLoc[22](loc18: vector<u128>)
MoveLoc[2](Arg2: u128)
VecPushBack(24)
MoveLoc[44](loc40: vector<u128>)
StLoc[31](loc27: vector<u128>)
MutBorrowLoc[31](loc27: vector<u128>)
MoveLoc[35](loc31: u64)
LdU64(1)
Sub
Call utils::pop_n<u128>(&mut vector<u128>, u64): vector<u128>
StLoc[46](loc42: vector<u128>)
MutBorrowLoc[31](loc27: vector<u128>)
VecPopBack(24)
StLoc[41](loc37: u128)
MutBorrowLoc[22](loc18: vector<u128>)
MoveLoc[31](loc27: vector<u128>)
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MoveLoc[22](loc18: vector<u128>)
MoveLoc[41](loc37: u128)
MoveLoc[46](loc42: vector<u128>)
StLoc[4](loc0: vector<u128>)
StLoc[18](loc14: u128)
StLoc[17](loc13: vector<u128>)
B31:
MoveLoc[17](loc13: vector<u128>)
MoveLoc[18](loc14: u128)
MoveLoc[4](loc0: vector<u128>)
StLoc[7](loc3: vector<u128>)
StLoc[6](loc2: u128)
StLoc[5](loc1: vector<u128>)
B32:
MoveLoc[5](loc1: vector<u128>)
MoveLoc[6](loc2: u128)
MoveLoc[7](loc3: vector<u128>)
StLoc[10](loc6: vector<u128>)
StLoc[9](loc5: u128)
StLoc[8](loc4: vector<u128>)
B33:
MoveLoc[8](loc4: vector<u128>)
MoveLoc[9](loc5: u128)
MoveLoc[10](loc6: vector<u128>)
StLoc[47](loc43: vector<u128>)
StLoc[42](loc38: u128)
StLoc[23](loc19: vector<u128>)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[1](Arg1: u64)
MoveLoc[25](loc21: u64)
MoveLoc[24](loc20: u64)
MoveLoc[23](loc19: vector<u128>)
MoveLoc[27](loc23: vector<Ty1>)
PackGeneric[3](Slice<Ty1>)
Call dynamic_field::add<u64, Slice<Ty1>>(&mut UID, u64, Slice<Ty1>)
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[3](Arg3: u64)
MoveLoc[49](loc45: u64)
MoveLoc[48](loc44: u64)
MoveLoc[47](loc43: vector<u128>)
MoveLoc[52](loc48: vector<Ty1>)
PackGeneric[3](Slice<Ty1>)
Call dynamic_field::add<u64, Slice<Ty1>>(&mut UID, u64, Slice<Ty1>)
MoveLoc[42](loc38: u128)
Ret
}
slice_merge<Ty0: store, Ty1: store>(Arg0: &mut BigVector<Ty0>, Arg1: u64, Arg2: u128, Arg3: u64) {
L4:	loc0: vector<u128>
L5:	loc1: &mut Slice<Ty1>
L6:	loc2: u64
L7:	loc3: &mut Slice<Ty1>
L8:	loc4: Slice<Ty1>
L9:	loc5: vector<Ty1>
B0:
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[3](Arg3: u64)
Call dynamic_field::remove<u64, Slice<Ty1>>(&mut UID, u64): Slice<Ty1>
StLoc[8](loc4: Slice<Ty1>)
CopyLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
CopyLoc[1](Arg1: u64)
Call dynamic_field::borrow_mut<u64, Slice<Ty1>>(&mut UID, u64): &mut Slice<Ty1>
StLoc[5](loc1: &mut Slice<Ty1>)
CopyLoc[5](loc1: &mut Slice<Ty1>)
ImmBorrowFieldGeneric[10](Slice.next: u64)
ReadRef
MoveLoc[3](Arg3: u64)
Eq
BrFalse(17)
B1:
Branch(23)
B2:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[5](loc1: &mut Slice<Ty1>)
Pop
LdConst[8](u64: 8)
Abort
B3:
ImmBorrowLoc[8](loc4: Slice<Ty1>)
ImmBorrowFieldGeneric[9](Slice.prev: u64)
ReadRef
CopyLoc[1](Arg1: u64)
Eq
BrFalse(30)
B4:
Branch(36)
B5:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
MoveLoc[5](loc1: &mut Slice<Ty1>)
Pop
LdConst[8](u64: 8)
Abort
B6:
CopyLoc[5](loc1: &mut Slice<Ty1>)
FreezeRef
Call slice_is_leaf<Ty1>(&Slice<Ty1>): bool
Not
BrFalse(45)
B7:
CopyLoc[5](loc1: &mut Slice<Ty1>)
MutBorrowFieldGeneric[16](Slice.keys: vector<u128>)
MoveLoc[2](Arg2: u128)
VecPushBack(24)
B8:
MoveLoc[8](loc4: Slice<Ty1>)
UnpackGeneric[3](Slice<Ty1>)
StLoc[9](loc5: vector<Ty1>)
StLoc[4](loc0: vector<u128>)
StLoc[6](loc2: u64)
Pop
CopyLoc[5](loc1: &mut Slice<Ty1>)
MutBorrowFieldGeneric[16](Slice.keys: vector<u128>)
MoveLoc[4](loc0: vector<u128>)
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
CopyLoc[5](loc1: &mut Slice<Ty1>)
MutBorrowFieldGeneric[17](Slice.vals: vector<Ty1>)
MoveLoc[9](loc5: vector<Ty1>)
Call vector::append<Ty1>(&mut vector<Ty1>, vector<Ty1>)
CopyLoc[6](loc2: u64)
MoveLoc[5](loc1: &mut Slice<Ty1>)
MutBorrowFieldGeneric[10](Slice.next: u64)
WriteRef
CopyLoc[6](loc2: u64)
LdConst[0](u64: 0)
Neq
BrFalse(77)
B9:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
MutBorrowFieldGeneric[3](BigVector.id: UID)
MoveLoc[6](loc2: u64)
Call dynamic_field::borrow_mut<u64, Slice<Ty1>>(&mut UID, u64): &mut Slice<Ty1>
StLoc[7](loc3: &mut Slice<Ty1>)
MoveLoc[1](Arg1: u64)
MoveLoc[7](loc3: &mut Slice<Ty1>)
MutBorrowFieldGeneric[9](Slice.prev: u64)
WriteRef
Branch(79)
B10:
MoveLoc[0](Arg0: &mut BigVector<Ty0>)
Pop
B11:
Ret
}
Constants [
=> u64: 0
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 6
=> u64: 7
=> u64: 8
=> u64: 9
=> u64: 4096
=> u64: 262144
=> u8: 0
=> u8: 1
=> u8: 2
=> u8: 3
=> u8: 4
=> u8: 5
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/book.mvb1478 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.book {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::big_vector;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::deep_price;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::fill;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order_info;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct Book has store {
	tick_size: u64,
	lot_size: u64,
	min_size: u64,
	bids: BigVector<Order>,
	asks: BigVector<Order>,
	next_bid_order_id: u64,
	next_ask_order_id: u64
}
public(friend) bids(Arg0: &Book): &BigVector<Order> {
B0:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
Ret
}
public(friend) asks(Arg0: &Book): &BigVector<Order> {
B0:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
Ret
}
public(friend) tick_size(Arg0: &Book): u64 {
B0:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[2](Book.tick_size: u64)
ReadRef
Ret
}
public(friend) lot_size(Arg0: &Book): u64 {
B0:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[3](Book.lot_size: u64)
ReadRef
Ret
}
public(friend) min_size(Arg0: &Book): u64 {
B0:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[4](Book.min_size: u64)
ReadRef
Ret
}
public(friend) empty(Arg0: u64, Arg1: u64, Arg2: u64, Arg3: &mut TxContext): Book {
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
Call constants::max_slice_size(): u64
Call constants::max_fan_out(): u64
CopyLoc[3](Arg3: &mut TxContext)
Call big_vector::empty<Order>(u64, u64, &mut TxContext): BigVector<Order>
Call constants::max_slice_size(): u64
Call constants::max_fan_out(): u64
MoveLoc[3](Arg3: &mut TxContext)
Call big_vector::empty<Order>(u64, u64, &mut TxContext): BigVector<Order>
LdConst[7](u64: 1844..)
LdConst[0](u64: 1)
Pack[0](Book)
Ret
}
public(friend) create_order(Arg0: &mut Book, Arg1: &mut OrderInfo, Arg2: u64) {
L3:	loc0: u128
B0:
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[2](Book.tick_size: u64)
ReadRef
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[4](Book.min_size: u64)
ReadRef
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[3](Book.lot_size: u64)
ReadRef
CopyLoc[2](Arg2: u64)
Call order_info::validate_inputs(&OrderInfo, u64, u64, u64, u64)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::is_bid(&OrderInfo): bool
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::price(&OrderInfo): u64
CopyLoc[0](Arg0: &mut Book)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::is_bid(&OrderInfo): bool
Call get_order_id(&mut Book, bool): u64
Call utils::encode_order_id(bool, u64, u64): u128
StLoc[3](loc0: u128)
CopyLoc[1](Arg1: &mut OrderInfo)
MoveLoc[3](loc0: u128)
Call order_info::set_order_id(&mut OrderInfo, u128)
CopyLoc[0](Arg0: &mut Book)
CopyLoc[1](Arg1: &mut OrderInfo)
MoveLoc[2](Arg2: u64)
Call match_against_book(&mut Book, &mut OrderInfo, u64)
CopyLoc[1](Arg1: &mut OrderInfo)
Call order_info::assert_execution(&mut OrderInfo): bool
BrFalse(41)
B1:
MoveLoc[0](Arg0: &mut Book)
Pop
MoveLoc[1](Arg1: &mut OrderInfo)
Pop
Ret
B2:
MoveLoc[0](Arg0: &mut Book)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call inject_limit_order(&mut Book, &OrderInfo)
CopyLoc[1](Arg1: &mut OrderInfo)
Call order_info::set_order_inserted(&mut OrderInfo)
MoveLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::emit_order_placed(&OrderInfo)
Ret
}
public(friend) get_quantity_out(Arg0: &Book, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: OrderDeepPrice, Arg5: u64, Arg6: bool, Arg7: u64): u64 * u64 * u64 {
L8:	loc0: u64
L9:	loc1: u64
L10:	loc2: u64
L11:	loc3: u64
L12:	loc4: u64
L13:	loc5: &BigVector<Order>
L14:	loc6: SliceRef
L15:	loc7: u64
L16:	loc8: bool
L17:	loc9: u64
L18:	loc10: SliceRef
L19:	loc11: u64
L20:	loc12: Balances
L21:	loc13: &BigVector<Order>
L22:	loc14: u64
L23:	loc15: u64
L24:	loc16: u64
L25:	loc17: u64
L26:	loc18: Balances
L27:	loc19: u64
L28:	loc20: bool
L29:	loc21: u64
L30:	loc22: u64
L31:	loc23: u64
L32:	loc24: u64
L33:	loc25: &Order
L34:	loc26: u64
L35:	loc27: u64
L36:	loc28: u64
L37:	loc29: SliceRef
B0:
CopyLoc[1](Arg1: u64)
LdU64(0)
Gt
CopyLoc[2](Arg2: u64)
LdU64(0)
Gt
Neq
BrFalse(9)
B1:
Branch(13)
B2:
MoveLoc[0](Arg0: &Book)
Pop
LdConst[0](u64: 1)
Abort
B3:
CopyLoc[2](Arg2: u64)
LdU64(0)
Gt
StLoc[28](loc20: bool)
LdU64(0)
StLoc[35](loc27: u64)
CopyLoc[28](loc20: bool)
BrFalse(24)
B4:
CopyLoc[2](Arg2: u64)
StLoc[8](loc0: u64)
Branch(26)
B5:
CopyLoc[1](Arg1: u64)
StLoc[8](loc0: u64)
B6:
MoveLoc[8](loc0: u64)
StLoc[34](loc26: u64)
Call constants::fee_penalty_multiplier(): u64
CopyLoc[3](Arg3: u64)
Call math::mul(u64, u64): u64
StLoc[27](loc19: u64)
CopyLoc[28](loc20: bool)
BrFalse(38)
B7:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
StLoc[13](loc5: &BigVector<Order>)
Branch(41)
B8:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
StLoc[13](loc5: &BigVector<Order>)
B9:
MoveLoc[13](loc5: &BigVector<Order>)
StLoc[21](loc13: &BigVector<Order>)
CopyLoc[28](loc20: bool)
BrFalse(50)
B10:
CopyLoc[21](loc13: &BigVector<Order>)
Call big_vector::min_slice<Order>(&BigVector<Order>): SliceRef * u64
StLoc[15](loc7: u64)
StLoc[14](loc6: SliceRef)
Branch(54)
B11:
CopyLoc[21](loc13: &BigVector<Order>)
Call big_vector::max_slice<Order>(&BigVector<Order>): SliceRef * u64
StLoc[15](loc7: u64)
StLoc[14](loc6: SliceRef)
B12:
MoveLoc[14](loc6: SliceRef)
MoveLoc[15](loc7: u64)
StLoc[32](loc24: u64)
StLoc[37](loc29: SliceRef)
Call constants::max_fills(): u64
StLoc[31](loc23: u64)
LdU64(0)
StLoc[24](loc16: u64)
B13:
ImmBorrowLoc[37](loc29: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
BrFalse(79)
B14:
CopyLoc[34](loc26: u64)
LdU64(0)
Gt
BrFalse(76)
B15:
Branch(71)
B16:
CopyLoc[24](loc16: u64)
CopyLoc[31](loc23: u64)
Lt
StLoc[16](loc8: bool)
Branch(81)
B17:
LdFalse
StLoc[16](loc8: bool)
Branch(81)
B18:
LdFalse
StLoc[16](loc8: bool)
B19:
MoveLoc[16](loc8: bool)
BrFalse(212)
B20:
CopyLoc[21](loc13: &BigVector<Order>)
CopyLoc[37](loc29: SliceRef)
Call big_vector::borrow_slice<Order>(&BigVector<Order>, SliceRef): &Slice<Order>
CopyLoc[32](loc24: u64)
Call big_vector::slice_borrow<Order>(&Slice<Order>, u64): &Order
StLoc[33](loc25: &Order)
CopyLoc[33](loc25: &Order)
Call order::price(&Order): u64
StLoc[22](loc14: u64)
CopyLoc[33](loc25: &Order)
Call order::quantity(&Order): u64
CopyLoc[33](loc25: &Order)
Call order::filled_quantity(&Order): u64
Sub
StLoc[23](loc15: u64)
CopyLoc[7](Arg7: u64)
MoveLoc[33](loc25: &Order)
Call order::expire_timestamp(&Order): u64
Le
BrFalse(188)
B21:
CopyLoc[6](Arg6: bool)
BrFalse(108)
B22:
CopyLoc[34](loc26: u64)
StLoc[17](loc9: u64)
Branch(114)
B23:
CopyLoc[34](loc26: u64)
Call constants::float_scaling(): u64
CopyLoc[27](loc19: u64)
Add
Call math::div(u64, u64): u64
StLoc[17](loc9: u64)
B24:
MoveLoc[17](loc9: u64)
StLoc[36](loc28: u64)
CopyLoc[28](loc20: bool)
BrFalse(152)
B25:
MoveLoc[36](loc28: u64)
CopyLoc[22](loc14: u64)
Call math::div(u64, u64): u64
MoveLoc[23](loc15: u64)
Call u64::min(u64, u64): u64
StLoc[29](loc21: u64)
CopyLoc[29](loc21: u64)
MoveLoc[29](loc21: u64)
CopyLoc[5](Arg5: u64)
Mod
Sub
StLoc[29](loc21: u64)
MoveLoc[35](loc27: u64)
CopyLoc[29](loc21: u64)
Add
StLoc[35](loc27: u64)
CopyLoc[29](loc21: u64)
MoveLoc[22](loc14: u64)
Call math::mul(u64, u64): u64
StLoc[30](loc22: u64)
MoveLoc[34](loc26: u64)
CopyLoc[30](loc22: u64)
Sub
StLoc[34](loc26: u64)
CopyLoc[6](Arg6: bool)
Not
BrFalse(181)
B26:
MoveLoc[34](loc26: u64)
MoveLoc[30](loc22: u64)
CopyLoc[27](loc19: u64)
Call math::mul(u64, u64): u64
Sub
StLoc[34](loc26: u64)
Branch(181)
B27:
MoveLoc[36](loc28: u64)
MoveLoc[23](loc15: u64)
Call u64::min(u64, u64): u64
StLoc[29](loc21: u64)
CopyLoc[29](loc21: u64)
MoveLoc[29](loc21: u64)
CopyLoc[5](Arg5: u64)
Mod
Sub
StLoc[29](loc21: u64)
MoveLoc[35](loc27: u64)
CopyLoc[29](loc21: u64)
MoveLoc[22](loc14: u64)
Call math::mul(u64, u64): u64
Add
StLoc[35](loc27: u64)
MoveLoc[34](loc26: u64)
CopyLoc[29](loc21: u64)
Sub
StLoc[34](loc26: u64)
CopyLoc[6](Arg6: bool)
Not
BrFalse(181)
B28:
MoveLoc[34](loc26: u64)
CopyLoc[29](loc21: u64)
CopyLoc[27](loc19: u64)
Call math::mul(u64, u64): u64
Sub
StLoc[34](loc26: u64)
B29:
MoveLoc[29](loc21: u64)
LdU64(0)
Eq
BrFalse(188)
B30:
MoveLoc[21](loc13: &BigVector<Order>)
Pop
Branch(212)
B31:
CopyLoc[28](loc20: bool)
BrFalse(197)
B32:
CopyLoc[21](loc13: &BigVector<Order>)
MoveLoc[37](loc29: SliceRef)
MoveLoc[32](loc24: u64)
Call big_vector::next_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[19](loc11: u64)
StLoc[18](loc10: SliceRef)
Branch(203)
B33:
CopyLoc[21](loc13: &BigVector<Order>)
MoveLoc[37](loc29: SliceRef)
MoveLoc[32](loc24: u64)
Call big_vector::prev_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[19](loc11: u64)
StLoc[18](loc10: SliceRef)
B34:
MoveLoc[18](loc10: SliceRef)
MoveLoc[19](loc11: u64)
StLoc[32](loc24: u64)
StLoc[37](loc29: SliceRef)
MoveLoc[24](loc16: u64)
LdU64(1)
Add
StLoc[24](loc16: u64)
Branch(62)
B35:
MoveLoc[6](Arg6: bool)
Not
BrFalse(218)
B36:
LdU64(0)
StLoc[9](loc1: u64)
Branch(244)
B37:
CopyLoc[28](loc20: bool)
BrFalse(229)
B38:
ImmBorrowLoc[4](Arg4: OrderDeepPrice)
CopyLoc[35](loc27: u64)
MoveLoc[2](Arg2: u64)
CopyLoc[34](loc26: u64)
Sub
CopyLoc[28](loc20: bool)
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[20](loc12: Balances)
Branch(237)
B39:
ImmBorrowLoc[4](Arg4: OrderDeepPrice)
MoveLoc[1](Arg1: u64)
CopyLoc[34](loc26: u64)
Sub
CopyLoc[35](loc27: u64)
CopyLoc[28](loc20: bool)
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[20](loc12: Balances)
B40:
MoveLoc[20](loc12: Balances)
StLoc[26](loc18: Balances)
MoveLoc[3](Arg3: u64)
ImmBorrowLoc[26](loc18: Balances)
Call balances::deep(&Balances): u64
Call math::mul(u64, u64): u64
StLoc[9](loc1: u64)
B41:
MoveLoc[9](loc1: u64)
StLoc[25](loc17: u64)
MoveLoc[28](loc20: bool)
BrFalse(255)
B42:
MoveLoc[35](loc27: u64)
MoveLoc[34](loc26: u64)
MoveLoc[25](loc17: u64)
StLoc[12](loc4: u64)
StLoc[11](loc3: u64)
StLoc[10](loc2: u64)
Branch(261)
B43:
MoveLoc[34](loc26: u64)
MoveLoc[35](loc27: u64)
MoveLoc[25](loc17: u64)
StLoc[12](loc4: u64)
StLoc[11](loc3: u64)
StLoc[10](loc2: u64)
B44:
MoveLoc[10](loc2: u64)
MoveLoc[11](loc3: u64)
MoveLoc[12](loc4: u64)
Ret
}
public(friend) cancel_order(Arg0: &mut Book, Arg1: u128): Order {
B0:
MoveLoc[0](Arg0: &mut Book)
CopyLoc[1](Arg1: u128)
Call book_side_mut(&mut Book, u128): &mut BigVector<Order>
MoveLoc[1](Arg1: u128)
Call big_vector::remove<Order>(&mut BigVector<Order>, u128): Order
Ret
}
public(friend) modify_order(Arg0: &mut Book, Arg1: u128, Arg2: u64, Arg3: u64): u64 * &Order {
L4:	loc0: u64
L5:	loc1: &mut Order
B0:
CopyLoc[2](Arg2: u64)
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[4](Book.min_size: u64)
ReadRef
Ge
BrFalse(7)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Book)
Pop
LdConst[4](u64: 5)
Abort
B3:
CopyLoc[2](Arg2: u64)
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[3](Book.lot_size: u64)
ReadRef
Mod
LdU64(0)
Eq
BrFalse(20)
B4:
Branch(24)
B5:
MoveLoc[0](Arg0: &mut Book)
Pop
LdConst[5](u64: 6)
Abort
B6:
MoveLoc[0](Arg0: &mut Book)
CopyLoc[1](Arg1: u128)
Call book_side_mut(&mut Book, u128): &mut BigVector<Order>
MoveLoc[1](Arg1: u128)
Call big_vector::borrow_mut<Order>(&mut BigVector<Order>, u128): &mut Order
StLoc[5](loc1: &mut Order)
CopyLoc[2](Arg2: u64)
CopyLoc[5](loc1: &mut Order)
FreezeRef
Call order::quantity(&Order): u64
Lt
BrFalse(37)
B7:
Branch(41)
B8:
MoveLoc[5](loc1: &mut Order)
Pop
LdConst[6](u64: 7)
Abort
B9:
CopyLoc[5](loc1: &mut Order)
FreezeRef
Call order::quantity(&Order): u64
CopyLoc[2](Arg2: u64)
Sub
StLoc[4](loc0: u64)
CopyLoc[5](loc1: &mut Order)
MoveLoc[2](Arg2: u64)
MoveLoc[3](Arg3: u64)
Call order::modify(&mut Order, u64, u64)
MoveLoc[4](loc0: u64)
MoveLoc[5](loc1: &mut Order)
FreezeRef
Ret
}
public(friend) mid_price(Arg0: &Book, Arg1: u64): u64 {
L2:	loc0: bool
L3:	loc1: u64
L4:	loc2: SliceRef
L5:	loc3: &Order
L6:	loc4: u64
L7:	loc5: &Order
L8:	loc6: u64
L9:	loc7: u64
L10:	loc8: SliceRef
B0:
CopyLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
Call big_vector::min_slice<Order>(&BigVector<Order>): SliceRef * u64
StLoc[3](loc1: u64)
StLoc[4](loc2: SliceRef)
CopyLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
Call big_vector::max_slice<Order>(&BigVector<Order>): SliceRef * u64
StLoc[9](loc7: u64)
StLoc[10](loc8: SliceRef)
LdU64(0)
StLoc[6](loc4: u64)
LdU64(0)
StLoc[8](loc6: u64)
B1:
ImmBorrowLoc[4](loc2: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
BrFalse(43)
B2:
Branch(19)
B3:
CopyLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
CopyLoc[4](loc2: SliceRef)
Call big_vector::borrow_slice<Order>(&BigVector<Order>, SliceRef): &Slice<Order>
CopyLoc[3](loc1: u64)
Call big_vector::slice_borrow<Order>(&Slice<Order>, u64): &Order
StLoc[5](loc3: &Order)
CopyLoc[5](loc3: &Order)
Call order::price(&Order): u64
StLoc[6](loc4: u64)
CopyLoc[1](Arg1: u64)
MoveLoc[5](loc3: &Order)
Call order::expire_timestamp(&Order): u64
Le
BrFalse(35)
B4:
Branch(43)
B5:
CopyLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
MoveLoc[4](loc2: SliceRef)
MoveLoc[3](loc1: u64)
Call big_vector::next_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[3](loc1: u64)
StLoc[4](loc2: SliceRef)
Branch(14)
B6:
ImmBorrowLoc[10](loc8: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
BrFalse(73)
B7:
CopyLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
CopyLoc[10](loc8: SliceRef)
Call big_vector::borrow_slice<Order>(&BigVector<Order>, SliceRef): &Slice<Order>
CopyLoc[9](loc7: u64)
Call big_vector::slice_borrow<Order>(&Slice<Order>, u64): &Order
StLoc[7](loc5: &Order)
CopyLoc[7](loc5: &Order)
Call order::price(&Order): u64
StLoc[8](loc6: u64)
CopyLoc[1](Arg1: u64)
MoveLoc[7](loc5: &Order)
Call order::expire_timestamp(&Order): u64
Le
BrFalse(65)
B8:
MoveLoc[0](Arg0: &Book)
Pop
Branch(73)
B9:
CopyLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
MoveLoc[10](loc8: SliceRef)
MoveLoc[9](loc7: u64)
Call big_vector::prev_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[9](loc7: u64)
StLoc[10](loc8: SliceRef)
Branch(43)
B10:
ImmBorrowLoc[4](loc2: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
BrFalse(82)
B11:
ImmBorrowLoc[10](loc8: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
StLoc[2](loc0: bool)
Branch(84)
B12:
LdFalse
StLoc[2](loc0: bool)
B13:
MoveLoc[2](loc0: bool)
BrFalse(87)
B14:
Branch(89)
B15:
LdConst[1](u64: 2)
Abort
B16:
MoveLoc[6](loc4: u64)
MoveLoc[8](loc6: u64)
Add
Call constants::half(): u64
Call math::mul(u64, u64): u64
Ret
}
public(friend) get_level2_range_and_ticks(Arg0: &Book, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: bool, Arg5: u64): vector<u64> * vector<u64> {
L6:	loc0: bool
L7:	loc1: bool
L8:	loc2: bool
L9:	loc3: bool
L10:	loc4: bool
L11:	loc5: bool
L12:	loc6: bool
L13:	loc7: SliceRef
L14:	loc8: u64
L15:	loc9: bool
L16:	loc10: bool
L17:	loc11: u128
L18:	loc12: &BigVector<Order>
L19:	loc13: SliceRef
L20:	loc14: u64
L21:	loc15: bool
L22:	loc16: bool
L23:	loc17: bool
L24:	loc18: &BigVector<Order>
L25:	loc19: u64
L26:	loc20: u64
L27:	loc21: u128
L28:	loc22: u128
L29:	loc23: u128
L30:	loc24: u64
L31:	loc25: &Order
L32:	loc26: u64
L33:	loc27: vector<u64>
L34:	loc28: vector<u64>
L35:	loc29: SliceRef
L36:	loc30: u64
B0:
CopyLoc[1](Arg1: u64)
CopyLoc[2](Arg2: u64)
Le
BrFalse(5)
B1:
Branch(9)
B2:
MoveLoc[0](Arg0: &Book)
Pop
LdConst[2](u64: 3)
Abort
B3:
CopyLoc[1](Arg1: u64)
Call constants::min_price(): u64
Ge
BrFalse(18)
B4:
CopyLoc[1](Arg1: u64)
Call constants::max_price(): u64
Le
StLoc[6](loc0: bool)
Branch(20)
B5:
LdFalse
StLoc[6](loc0: bool)
B6:
MoveLoc[6](loc0: bool)
BrFalse(23)
B7:
Branch(27)
B8:
MoveLoc[0](Arg0: &Book)
Pop
LdConst[2](u64: 3)
Abort
B9:
CopyLoc[2](Arg2: u64)
Call constants::min_price(): u64
Ge
BrFalse(36)
B10:
CopyLoc[2](Arg2: u64)
Call constants::max_price(): u64
Le
StLoc[16](loc10: bool)
Branch(38)
B11:
LdFalse
StLoc[16](loc10: bool)
B12:
MoveLoc[16](loc10: bool)
BrFalse(41)
B13:
Branch(45)
B14:
MoveLoc[0](Arg0: &Book)
Pop
LdConst[2](u64: 3)
Abort
B15:
CopyLoc[3](Arg3: u64)
LdU64(0)
Gt
BrFalse(50)
B16:
Branch(54)
B17:
MoveLoc[0](Arg0: &Book)
Pop
LdConst[3](u64: 4)
Abort
B18:
LdConst[8](vector<u64>: 00)
StLoc[33](loc27: vector<u64>)
LdConst[8](vector<u64>: 00)
StLoc[34](loc28: vector<u64>)
CopyLoc[4](Arg4: bool)
BrFalse(63)
B19:
LdU128(0)
StLoc[17](loc11: u128)
Branch(65)
B20:
LdU128(170141183460469231731687303715884105728)
StLoc[17](loc11: u128)
B21:
MoveLoc[17](loc11: u128)
StLoc[29](loc23: u128)
CopyLoc[1](Arg1: u64)
CastU128
LdU8(64)
Shl
CopyLoc[29](loc23: u128)
Add
StLoc[28](loc22: u128)
CopyLoc[2](Arg2: u64)
CastU128
LdU8(64)
Shl
LdU128(18446744073709551615)
Add
MoveLoc[29](loc23: u128)
Add
StLoc[27](loc21: u128)
CopyLoc[4](Arg4: bool)
BrFalse(89)
B22:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
StLoc[18](loc12: &BigVector<Order>)
Branch(92)
B23:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
StLoc[18](loc12: &BigVector<Order>)
B24:
MoveLoc[18](loc12: &BigVector<Order>)
StLoc[24](loc18: &BigVector<Order>)
CopyLoc[4](Arg4: bool)
BrFalse(102)
B25:
CopyLoc[24](loc18: &BigVector<Order>)
MoveLoc[27](loc21: u128)
Call big_vector::slice_before<Order>(&BigVector<Order>, u128): SliceRef * u64
StLoc[20](loc14: u64)
StLoc[19](loc13: SliceRef)
Branch(107)
B26:
CopyLoc[24](loc18: &BigVector<Order>)
MoveLoc[28](loc22: u128)
Call big_vector::slice_following<Order>(&BigVector<Order>, u128): SliceRef * u64
StLoc[20](loc14: u64)
StLoc[19](loc13: SliceRef)
B27:
MoveLoc[19](loc13: SliceRef)
MoveLoc[20](loc14: u64)
StLoc[30](loc24: u64)
StLoc[35](loc29: SliceRef)
MoveLoc[3](Arg3: u64)
StLoc[36](loc30: u64)
LdU64(0)
StLoc[25](loc19: u64)
LdU64(0)
StLoc[26](loc20: u64)
B28:
ImmBorrowLoc[35](loc29: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
BrFalse(126)
B29:
CopyLoc[36](loc30: u64)
LdU64(0)
Gt
StLoc[21](loc15: bool)
Branch(128)
B30:
LdFalse
StLoc[21](loc15: bool)
B31:
MoveLoc[21](loc15: bool)
BrFalse(294)
B32:
CopyLoc[24](loc18: &BigVector<Order>)
CopyLoc[35](loc29: SliceRef)
Call big_vector::borrow_slice<Order>(&BigVector<Order>, SliceRef): &Slice<Order>
CopyLoc[30](loc24: u64)
Call big_vector::slice_borrow<Order>(&Slice<Order>, u64): &Order
StLoc[31](loc25: &Order)
CopyLoc[5](Arg5: u64)
CopyLoc[31](loc25: &Order)
Call order::expire_timestamp(&Order): u64
Le
BrFalse(272)
B33:
Branch(142)
B34:
CopyLoc[31](loc25: &Order)
Call order::order_id(&Order): u128
Call utils::decode_order_id(u128): bool * u64 * u64
Pop
StLoc[32](loc26: u64)
Pop
CopyLoc[4](Arg4: bool)
BrFalse(155)
B35:
CopyLoc[32](loc26: u64)
CopyLoc[1](Arg1: u64)
Lt
StLoc[7](loc1: bool)
Branch(157)
B36:
LdFalse
StLoc[7](loc1: bool)
B37:
MoveLoc[7](loc1: bool)
BrFalse(162)
B38:
LdTrue
StLoc[22](loc16: bool)
Branch(174)
B39:
CopyLoc[4](Arg4: bool)
Not
BrFalse(170)
B40:
CopyLoc[32](loc26: u64)
CopyLoc[2](Arg2: u64)
Gt
StLoc[23](loc17: bool)
Branch(172)
B41:
LdFalse
StLoc[23](loc17: bool)
B42:
MoveLoc[23](loc17: bool)
StLoc[22](loc16: bool)
B43:
MoveLoc[22](loc16: bool)
BrFalse(181)
B44:
MoveLoc[31](loc25: &Order)
Pop
MoveLoc[24](loc18: &BigVector<Order>)
Pop
Branch(294)
B45:
CopyLoc[25](loc19: u64)
LdU64(0)
Eq
BrFalse(214)
B46:
CopyLoc[4](Arg4: bool)
BrFalse(192)
B47:
CopyLoc[32](loc26: u64)
CopyLoc[2](Arg2: u64)
Le
StLoc[11](loc5: bool)
Branch(194)
B48:
LdFalse
StLoc[11](loc5: bool)
B49:
MoveLoc[11](loc5: bool)
BrFalse(199)
B50:
LdTrue
StLoc[9](loc3: bool)
Branch(211)
B51:
CopyLoc[4](Arg4: bool)
Not
BrFalse(207)
B52:
CopyLoc[32](loc26: u64)
CopyLoc[1](Arg1: u64)
Ge
StLoc[10](loc4: bool)
Branch(209)
B53:
LdFalse
StLoc[10](loc4: bool)
B54:
MoveLoc[10](loc4: bool)
StLoc[9](loc3: bool)
B55:
MoveLoc[9](loc3: bool)
StLoc[8](loc2: bool)
Branch(216)
B56:
LdFalse
StLoc[8](loc2: bool)
B57:
MoveLoc[8](loc2: bool)
BrFalse(220)
B58:
CopyLoc[32](loc26: u64)
StLoc[25](loc19: u64)
B59:
CopyLoc[25](loc19: u64)
LdU64(0)
Neq
BrFalse(229)
B60:
CopyLoc[32](loc26: u64)
CopyLoc[25](loc19: u64)
Neq
StLoc[12](loc6: bool)
Branch(231)
B61:
LdFalse
StLoc[12](loc6: bool)
B62:
MoveLoc[12](loc6: bool)
BrFalse(256)
B63:
MutBorrowLoc[33](loc27: vector<u64>)
MoveLoc[25](loc19: u64)
VecPushBack(2)
MutBorrowLoc[34](loc28: vector<u64>)
MoveLoc[26](loc20: u64)
VecPushBack(2)
MoveLoc[32](loc26: u64)
StLoc[25](loc19: u64)
LdU64(0)
StLoc[26](loc20: u64)
MoveLoc[36](loc30: u64)
LdU64(1)
Sub
StLoc[36](loc30: u64)
CopyLoc[36](loc30: u64)
LdU64(0)
Eq
BrFalse(256)
B64:
MoveLoc[31](loc25: &Order)
Pop
MoveLoc[24](loc18: &BigVector<Order>)
Pop
Branch(294)
B65:
CopyLoc[25](loc19: u64)
LdU64(0)
Neq
BrFalse(269)
B66:
MoveLoc[26](loc20: u64)
CopyLoc[31](loc25: &Order)
Call order::quantity(&Order): u64
Add
MoveLoc[31](loc25: &Order)
Call order::filled_quantity(&Order): u64
Sub
StLoc[26](loc20: u64)
Branch(274)
B67:
MoveLoc[31](loc25: &Order)
Pop
Branch(274)
B68:
MoveLoc[31](loc25: &Order)
Pop
B69:
CopyLoc[4](Arg4: bool)
BrFalse(283)
B70:
CopyLoc[24](loc18: &BigVector<Order>)
MoveLoc[35](loc29: SliceRef)
MoveLoc[30](loc24: u64)
Call big_vector::prev_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[14](loc8: u64)
StLoc[13](loc7: SliceRef)
Branch(289)
B71:
CopyLoc[24](loc18: &BigVector<Order>)
MoveLoc[35](loc29: SliceRef)
MoveLoc[30](loc24: u64)
Call big_vector::next_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[14](loc8: u64)
StLoc[13](loc7: SliceRef)
B72:
MoveLoc[13](loc7: SliceRef)
MoveLoc[14](loc8: u64)
StLoc[30](loc24: u64)
StLoc[35](loc29: SliceRef)
Branch(117)
B73:
CopyLoc[25](loc19: u64)
LdU64(0)
Neq
BrFalse(303)
B74:
MoveLoc[36](loc30: u64)
LdU64(0)
Gt
StLoc[15](loc9: bool)
Branch(305)
B75:
LdFalse
StLoc[15](loc9: bool)
B76:
MoveLoc[15](loc9: bool)
BrFalse(313)
B77:
MutBorrowLoc[33](loc27: vector<u64>)
MoveLoc[25](loc19: u64)
VecPushBack(2)
MutBorrowLoc[34](loc28: vector<u64>)
MoveLoc[26](loc20: u64)
VecPushBack(2)
B78:
MoveLoc[33](loc27: vector<u64>)
MoveLoc[34](loc28: vector<u64>)
Ret
}
public(friend) get_order(Arg0: &Book, Arg1: u128): Order {
B0:
MoveLoc[0](Arg0: &Book)
CopyLoc[1](Arg1: u128)
Call book_side(&Book, u128): &BigVector<Order>
MoveLoc[1](Arg1: u128)
Call big_vector::borrow<Order>(&BigVector<Order>, u128): &Order
Call order::copy_order(&Order): Order
Ret
}
public(friend) set_tick_size(Arg0: &mut Book, Arg1: u64) {
B0:
MoveLoc[1](Arg1: u64)
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[2](Book.tick_size: u64)
WriteRef
Ret
}
public(friend) set_lot_size(Arg0: &mut Book, Arg1: u64) {
B0:
MoveLoc[1](Arg1: u64)
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[3](Book.lot_size: u64)
WriteRef
Ret
}
public(friend) set_min_size(Arg0: &mut Book, Arg1: u64) {
B0:
MoveLoc[1](Arg1: u64)
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[4](Book.min_size: u64)
WriteRef
Ret
}
book_side_mut(Arg0: &mut Book, Arg1: u128): &mut BigVector<Order> {
L2:	loc0: &mut BigVector<Order>
B0:
MoveLoc[1](Arg1: u128)
Call utils::decode_order_id(u128): bool * u64 * u64
Pop
Pop
BrFalse(9)
B1:
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[0](Book.bids: BigVector<Order>)
StLoc[2](loc0: &mut BigVector<Order>)
Branch(12)
B2:
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[1](Book.asks: BigVector<Order>)
StLoc[2](loc0: &mut BigVector<Order>)
B3:
MoveLoc[2](loc0: &mut BigVector<Order>)
Ret
}
book_side(Arg0: &Book, Arg1: u128): &BigVector<Order> {
L2:	loc0: &BigVector<Order>
B0:
MoveLoc[1](Arg1: u128)
Call utils::decode_order_id(u128): bool * u64 * u64
Pop
Pop
BrFalse(9)
B1:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[0](Book.bids: BigVector<Order>)
StLoc[2](loc0: &BigVector<Order>)
Branch(12)
B2:
MoveLoc[0](Arg0: &Book)
ImmBorrowField[1](Book.asks: BigVector<Order>)
StLoc[2](loc0: &BigVector<Order>)
B3:
MoveLoc[2](loc0: &BigVector<Order>)
Ret
}
match_against_book(Arg0: &mut Book, Arg1: &mut OrderInfo, Arg2: u64) {
L3:	loc0: u64
L4:	loc1: &mut BigVector<Order>
L5:	loc2: SliceRef
L6:	loc3: u64
L7:	loc4: bool
L8:	loc5: SliceRef
L9:	loc6: u64
L10:	loc7: bool
L11:	loc8: &mut BigVector<Order>
L12:	loc9: u64
L13:	loc10: &Fill
L14:	loc11: u64
L15:	loc12: u64
L16:	loc13: bool
L17:	loc14: &mut Order
L18:	loc15: u64
L19:	loc16: u64
L20:	loc17: SliceRef
L21:	loc18: u64
L22:	loc19: &mut vector<Fill>
B0:
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::is_bid(&OrderInfo): bool
StLoc[16](loc13: bool)
CopyLoc[16](loc13: bool)
BrFalse(10)
B1:
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[1](Book.asks: BigVector<Order>)
StLoc[4](loc1: &mut BigVector<Order>)
Branch(13)
B2:
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[0](Book.bids: BigVector<Order>)
StLoc[4](loc1: &mut BigVector<Order>)
B3:
MoveLoc[4](loc1: &mut BigVector<Order>)
StLoc[11](loc8: &mut BigVector<Order>)
CopyLoc[16](loc13: bool)
BrFalse(23)
B4:
CopyLoc[11](loc8: &mut BigVector<Order>)
FreezeRef
Call big_vector::min_slice<Order>(&BigVector<Order>): SliceRef * u64
StLoc[6](loc3: u64)
StLoc[5](loc2: SliceRef)
Branch(28)
B5:
CopyLoc[11](loc8: &mut BigVector<Order>)
FreezeRef
Call big_vector::max_slice<Order>(&BigVector<Order>): SliceRef * u64
StLoc[6](loc3: u64)
StLoc[5](loc2: SliceRef)
B6:
MoveLoc[5](loc2: SliceRef)
MoveLoc[6](loc3: u64)
StLoc[19](loc16: u64)
StLoc[20](loc17: SliceRef)
Call constants::max_fills(): u64
StLoc[18](loc15: u64)
LdU64(0)
StLoc[12](loc9: u64)
B7:
ImmBorrowLoc[20](loc17: SliceRef)
Call big_vector::slice_is_null(&SliceRef): bool
Not
BrFalse(46)
B8:
Branch(41)
B9:
CopyLoc[12](loc9: u64)
CopyLoc[18](loc15: u64)
Lt
StLoc[7](loc4: bool)
Branch(48)
B10:
LdFalse
StLoc[7](loc4: bool)
B11:
MoveLoc[7](loc4: bool)
BrFalse(89)
B12:
CopyLoc[11](loc8: &mut BigVector<Order>)
CopyLoc[20](loc17: SliceRef)
Call big_vector::borrow_slice_mut<Order>(&mut BigVector<Order>, SliceRef): &mut Slice<Order>
CopyLoc[19](loc16: u64)
Call big_vector::slice_borrow_mut<Order>(&mut Slice<Order>, u64): &mut Order
StLoc[17](loc14: &mut Order)
CopyLoc[1](Arg1: &mut OrderInfo)
MoveLoc[17](loc14: &mut Order)
CopyLoc[2](Arg2: u64)
Call order_info::match_maker(&mut OrderInfo, &mut Order, u64): bool
Not
BrFalse(63)
B13:
Branch(89)
B14:
CopyLoc[16](loc13: bool)
BrFalse(73)
B15:
CopyLoc[11](loc8: &mut BigVector<Order>)
FreezeRef
MoveLoc[20](loc17: SliceRef)
MoveLoc[19](loc16: u64)
Call big_vector::next_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[9](loc6: u64)
StLoc[8](loc5: SliceRef)
Branch(80)
B16:
CopyLoc[11](loc8: &mut BigVector<Order>)
FreezeRef
MoveLoc[20](loc17: SliceRef)
MoveLoc[19](loc16: u64)
Call big_vector::prev_slice<Order>(&BigVector<Order>, SliceRef, u64): SliceRef * u64
StLoc[9](loc6: u64)
StLoc[8](loc5: SliceRef)
B17:
MoveLoc[8](loc5: SliceRef)
MoveLoc[9](loc6: u64)
StLoc[19](loc16: u64)
StLoc[20](loc17: SliceRef)
MoveLoc[12](loc9: u64)
LdU64(1)
Add
StLoc[12](loc9: u64)
Branch(36)
B18:
CopyLoc[1](Arg1: &mut OrderInfo)
Call order_info::fills_ref(&mut OrderInfo): &mut vector<Fill>
StLoc[22](loc19: &mut vector<Fill>)
CopyLoc[22](loc19: &mut vector<Fill>)
FreezeRef
VecLen(58)
StLoc[3](loc0: u64)
LdU64(0)
StLoc[14](loc11: u64)
MoveLoc[3](loc0: u64)
StLoc[21](loc18: u64)
B19:
CopyLoc[14](loc11: u64)
CopyLoc[21](loc18: u64)
Lt
BrFalse(135)
B20:
CopyLoc[14](loc11: u64)
StLoc[15](loc12: u64)
CopyLoc[22](loc19: &mut vector<Fill>)
FreezeRef
MoveLoc[15](loc12: u64)
VecImmBorrow(58)
StLoc[13](loc10: &Fill)
CopyLoc[13](loc10: &Fill)
Call fill::expired(&Fill): bool
BrFalse(117)
B21:
LdTrue
StLoc[10](loc7: bool)
Branch(120)
B22:
CopyLoc[13](loc10: &Fill)
Call fill::completed(&Fill): bool
StLoc[10](loc7: bool)
B23:
MoveLoc[10](loc7: bool)
BrFalse(128)
B24:
CopyLoc[11](loc8: &mut BigVector<Order>)
MoveLoc[13](loc10: &Fill)
Call fill::maker_order_id(&Fill): u128
Call big_vector::remove<Order>(&mut BigVector<Order>, u128): Order
Pop
Branch(130)
B25:
MoveLoc[13](loc10: &Fill)
Pop
B26:
MoveLoc[14](loc11: u64)
LdU64(1)
Add
StLoc[14](loc11: u64)
Branch(100)
B27:
MoveLoc[22](loc19: &mut vector<Fill>)
Pop
MoveLoc[11](loc8: &mut BigVector<Order>)
Pop
MoveLoc[12](loc9: u64)
MoveLoc[18](loc15: u64)
Eq
BrFalse(146)
B28:
MoveLoc[1](Arg1: &mut OrderInfo)
Call order_info::set_fill_limit_reached(&mut OrderInfo)
Branch(148)
B29:
MoveLoc[1](Arg1: &mut OrderInfo)
Pop
B30:
Ret
}
get_order_id(Arg0: &mut Book, Arg1: bool): u64 {
L2:	loc0: u64
B0:
MoveLoc[1](Arg1: bool)
BrFalse(15)
B1:
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[5](Book.next_bid_order_id: u64)
ReadRef
LdU64(1)
Sub
CopyLoc[0](Arg0: &mut Book)
MutBorrowField[5](Book.next_bid_order_id: u64)
WriteRef
MoveLoc[0](Arg0: &mut Book)
ImmBorrowField[5](Book.next_bid_order_id: u64)
ReadRef
StLoc[2](loc0: u64)
Branch(27)
B2:
CopyLoc[0](Arg0: &mut Book)
ImmBorrowField[6](Book.next_ask_order_id: u64)
ReadRef
LdU64(1)
Add
CopyLoc[0](Arg0: &mut Book)
MutBorrowField[6](Book.next_ask_order_id: u64)
WriteRef
MoveLoc[0](Arg0: &mut Book)
ImmBorrowField[6](Book.next_ask_order_id: u64)
ReadRef
StLoc[2](loc0: u64)
B3:
MoveLoc[2](loc0: u64)
Ret
}
inject_limit_order(Arg0: &mut Book, Arg1: &OrderInfo) {
L2:	loc0: Order
B0:
CopyLoc[1](Arg1: &OrderInfo)
Call order_info::to_order(&OrderInfo): Order
StLoc[2](loc0: Order)
CopyLoc[1](Arg1: &OrderInfo)
Call order_info::is_bid(&OrderInfo): bool
BrFalse(13)
B1:
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[0](Book.bids: BigVector<Order>)
MoveLoc[1](Arg1: &OrderInfo)
Call order_info::order_id(&OrderInfo): u128
MoveLoc[2](loc0: Order)
Call big_vector::insert<Order>(&mut BigVector<Order>, u128, Order)
Branch(19)
B2:
MoveLoc[0](Arg0: &mut Book)
MutBorrowField[1](Book.asks: BigVector<Order>)
MoveLoc[1](Arg1: &OrderInfo)
Call order_info::order_id(&OrderInfo): u128
MoveLoc[2](loc0: Order)
Call big_vector::insert<Order>(&mut BigVector<Order>, u128, Order)
B3:
Ret
}
Constants [
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 6
=> u64: 7
=> u64: 18446744073709551615
=> vector<u64>: 00
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/constants.mvb213 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.constants {
public current_version(): u64 {
B0:
	0: LdConst[0](u64: 2)
	1: Ret
}
public pool_creation_fee(): u64 {
B0:
	0: LdConst[1](u64: 5000..)
	1: Ret
}
public float_scaling(): u64 {
B0:
	0: LdConst[2](u64: 1000..)
	1: Ret
}
public float_scaling_u128(): u128 {
B0:
	0: LdConst[3](u128: 1000..)
	1: Ret
}
public max_u64(): u64 {
B0:
	0: LdConst[4](u64: 1844..)
	1: Ret
}
public max_u128(): u128 {
B0:
	0: LdConst[5](u128: 3402..)
	1: Ret
}
public no_restriction(): u8 {
B0:
	0: LdConst[11](u8: 0)
	1: Ret
}
public immediate_or_cancel(): u8 {
B0:
	0: LdConst[12](u8: 1)
	1: Ret
}
public fill_or_kill(): u8 {
B0:
	0: LdConst[13](u8: 2)
	1: Ret
}
public post_only(): u8 {
B0:
	0: LdConst[14](u8: 3)
	1: Ret
}
public max_restriction(): u8 {
B0:
	0: LdConst[14](u8: 3)
	1: Ret
}
public live(): u8 {
B0:
	0: LdConst[11](u8: 0)
	1: Ret
}
public partially_filled(): u8 {
B0:
	0: LdConst[12](u8: 1)
	1: Ret
}
public filled(): u8 {
B0:
	0: LdConst[13](u8: 2)
	1: Ret
}
public canceled(): u8 {
B0:
	0: LdConst[14](u8: 3)
	1: Ret
}
public expired(): u8 {
B0:
	0: LdConst[15](u8: 4)
	1: Ret
}
public self_matching_allowed(): u8 {
B0:
	0: LdConst[11](u8: 0)
	1: Ret
}
public cancel_taker(): u8 {
B0:
	0: LdConst[12](u8: 1)
	1: Ret
}
public cancel_maker(): u8 {
B0:
	0: LdConst[13](u8: 2)
	1: Ret
}
public min_price(): u64 {
B0:
	0: LdConst[6](u64: 1)
	1: Ret
}
public max_price(): u64 {
B0:
	0: LdConst[7](u64: 9223..)
	1: Ret
}
public phase_out_epochs(): u64 {
B0:
	0: LdConst[18](u64: 28)
	1: Ret
}
public default_stake_required(): u64 {
B0:
	0: LdConst[8](u64: 1000..)
	1: Ret
}
public half(): u64 {
B0:
	0: LdConst[1](u64: 5000..)
	1: Ret
}
public fee_is_deep(): bool {
B0:
	0: LdConst[19](bool: true)
	1: Ret
}
public deep_unit(): u64 {
B0:
	0: LdConst[9](u64: 1000..)
	1: Ret
}
public max_fills(): u64 {
B0:
	0: LdConst[16](u64: 100)
	1: Ret
}
public max_open_orders(): u64 {
B0:
	0: LdConst[16](u64: 100)
	1: Ret
}
public max_slice_size(): u64 {
B0:
	0: LdConst[17](u64: 64)
	1: Ret
}
public max_fan_out(): u64 {
B0:
	0: LdConst[17](u64: 64)
	1: Ret
}
public fee_penalty_multiplier(): u64 {
B0:
	0: LdConst[10](u64: 1250..)
	1: Ret
}
Constants [
	0 => u64: 2
	1 => u64: 500000000
	2 => u64: 1000000000
	3 => u128: 1000000000
	4 => u64: 18446744073709551615
	5 => u128: 340282366920938463463374607431768211455
	6 => u64: 1
	7 => u64: 9223372036854775807
	8 => u64: 100000000
	9 => u64: 1000000
	10 => u64: 1250000000
	11 => u8: 0
	12 => u8: 1
	13 => u8: 2
	14 => u8: 3
	15 => u8: 4
	16 => u64: 100
	17 => u64: 64
	18 => u64: 28
	19 => bool: true
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/deep_price.mvb522 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.deep_price {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
struct Price has drop, store {
	conversion_rate: u64,
	timestamp: u64
}
struct PriceAdded has copy, drop {
	conversion_rate: u64,
	timestamp: u64,
	is_base_conversion: bool,
	reference_pool: ID,
	target_pool: ID
}
struct DeepPrice has drop, store {
	base_prices: vector<Price>,
	cumulative_base: u64,
	quote_prices: vector<Price>,
	cumulative_quote: u64
}
struct OrderDeepPrice has copy, drop, store {
	asset_is_base: bool,
	deep_per_asset: u64
}
public asset_is_base(Arg0: &OrderDeepPrice): bool {
B0:
MoveLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[0](OrderDeepPrice.asset_is_base: bool)
ReadRef
Ret
}
public deep_per_asset(Arg0: &OrderDeepPrice): u64 {
B0:
MoveLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[1](OrderDeepPrice.deep_per_asset: u64)
ReadRef
Ret
}
public(friend) empty(): DeepPrice {
B0:
VecPack(15, 0)
LdU64(0)
VecPack(15, 0)
LdU64(0)
Pack[2](DeepPrice)
Ret
}
public(friend) new_order_deep_price(Arg0: bool, Arg1: u64): OrderDeepPrice {
B0:
MoveLoc[0](Arg0: bool)
MoveLoc[1](Arg1: u64)
Pack[3](OrderDeepPrice)
Ret
}
public(friend) get_order_deep_price(Arg0: &DeepPrice, Arg1: bool): OrderDeepPrice {
B0:
MoveLoc[0](Arg0: &DeepPrice)
MoveLoc[1](Arg1: bool)
Call calculate_order_deep_price(&DeepPrice, bool): bool * u64
Call new_order_deep_price(bool, u64): OrderDeepPrice
Ret
}
public(friend) empty_deep_price(Arg0: &DeepPrice): OrderDeepPrice {
B0:
LdFalse
LdU64(0)
Call new_order_deep_price(bool, u64): OrderDeepPrice
Ret
}
public(friend) fee_quantity(Arg0: &OrderDeepPrice, Arg1: u64, Arg2: u64, Arg3: bool): Balances {
L4:	loc0: u64
L5:	loc1: Balances
L6:	loc2: Balances
L7:	loc3: u64
B0:
CopyLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[0](OrderDeepPrice.asset_is_base: bool)
ReadRef
BrFalse(11)
B1:
CopyLoc[1](Arg1: u64)
CopyLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[1](OrderDeepPrice.deep_per_asset: u64)
ReadRef
Call math::mul(u64, u64): u64
StLoc[4](loc0: u64)
Branch(17)
B2:
CopyLoc[2](Arg2: u64)
CopyLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[1](OrderDeepPrice.deep_per_asset: u64)
ReadRef
Call math::mul(u64, u64): u64
StLoc[4](loc0: u64)
B3:
MoveLoc[4](loc0: u64)
StLoc[7](loc3: u64)
MoveLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[1](OrderDeepPrice.deep_per_asset: u64)
ReadRef
LdU64(0)
Gt
BrFalse(31)
B4:
LdU64(0)
LdU64(0)
MoveLoc[7](loc3: u64)
Call balances::new(u64, u64, u64): Balances
StLoc[6](loc2: Balances)
Branch(50)
B5:
MoveLoc[3](Arg3: bool)
BrFalse(41)
B6:
LdU64(0)
MoveLoc[2](Arg2: u64)
Call constants::fee_penalty_multiplier(): u64
Call math::mul(u64, u64): u64
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[5](loc1: Balances)
Branch(48)
B7:
MoveLoc[1](Arg1: u64)
Call constants::fee_penalty_multiplier(): u64
Call math::mul(u64, u64): u64
LdU64(0)
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[5](loc1: Balances)
B8:
MoveLoc[5](loc1: Balances)
StLoc[6](loc2: Balances)
B9:
MoveLoc[6](loc2: Balances)
Ret
}
public(friend) deep_quantity_u128(Arg0: &OrderDeepPrice, Arg1: u128, Arg2: u128): u128 {
L3:	loc0: u128
B0:
CopyLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[0](OrderDeepPrice.asset_is_base: bool)
ReadRef
BrFalse(12)
B1:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[1](OrderDeepPrice.deep_per_asset: u64)
ReadRef
CastU128
Call math::mul_u128(u128, u128): u128
StLoc[3](loc0: u128)
Branch(19)
B2:
MoveLoc[2](Arg2: u128)
MoveLoc[0](Arg0: &OrderDeepPrice)
ImmBorrowField[1](OrderDeepPrice.deep_per_asset: u64)
ReadRef
CastU128
Call math::mul_u128(u128, u128): u128
StLoc[3](loc0: u128)
B3:
MoveLoc[3](loc0: u128)
Ret
}
public(friend) add_price_point(Arg0: &mut DeepPrice, Arg1: u64, Arg2: u64, Arg3: bool) {
L4:	loc0: &mut vector<Price>
L5:	loc1: u64
L6:	loc2: u64
L7:	loc3: &mut vector<Price>
L8:	loc4: bool
L9:	loc5: bool
L10:	loc6: &mut vector<Price>
B0:
CopyLoc[0](Arg0: &mut DeepPrice)
FreezeRef
CopyLoc[3](Arg3: bool)
Call last_insert_timestamp(&DeepPrice, bool): u64
LdConst[2](u64: 60000)
Add
CopyLoc[2](Arg2: u64)
Lt
BrFalse(10)
B1:
Branch(14)
B2:
MoveLoc[0](Arg0: &mut DeepPrice)
Pop
LdConst[0](u64: 1)
Abort
B3:
CopyLoc[3](Arg3: bool)
BrFalse(20)
B4:
CopyLoc[0](Arg0: &mut DeepPrice)
MutBorrowField[2](DeepPrice.base_prices: vector<Price>)
StLoc[4](loc0: &mut vector<Price>)
Branch(23)
B5:
CopyLoc[0](Arg0: &mut DeepPrice)
MutBorrowField[3](DeepPrice.quote_prices: vector<Price>)
StLoc[4](loc0: &mut vector<Price>)
B6:
MoveLoc[4](loc0: &mut vector<Price>)
StLoc[10](loc6: &mut vector<Price>)
CopyLoc[10](loc6: &mut vector<Price>)
StLoc[7](loc3: &mut vector<Price>)
CopyLoc[2](Arg2: u64)
StLoc[5](loc1: u64)
CopyLoc[1](Arg1: u64)
StLoc[6](loc2: u64)
MoveLoc[7](loc3: &mut vector<Price>)
MoveLoc[6](loc2: u64)
MoveLoc[5](loc1: u64)
Pack[0](Price)
VecPushBack(15)
MoveLoc[3](Arg3: bool)
BrFalse(93)
B7:
CopyLoc[0](Arg0: &mut DeepPrice)
ImmBorrowField[4](DeepPrice.cumulative_base: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Add
CopyLoc[0](Arg0: &mut DeepPrice)
MutBorrowField[4](DeepPrice.cumulative_base: u64)
WriteRef
B8:
CopyLoc[10](loc6: &mut vector<Price>)
FreezeRef
VecLen(15)
LdConst[4](u64: 100)
LdU64(1)
Add
Eq
BrFalse(57)
B9:
LdTrue
StLoc[8](loc4: bool)
Branch(68)
B10:
CopyLoc[10](loc6: &mut vector<Price>)
FreezeRef
LdU64(0)
VecImmBorrow(15)
ImmBorrowField[5](Price.timestamp: u64)
ReadRef
LdConst[3](u64: 8640..)
Add
CopyLoc[2](Arg2: u64)
Lt
StLoc[8](loc4: bool)
B11:
MoveLoc[8](loc4: bool)
BrFalse(88)
B12:
CopyLoc[0](Arg0: &mut DeepPrice)
ImmBorrowField[4](DeepPrice.cumulative_base: u64)
ReadRef
CopyLoc[10](loc6: &mut vector<Price>)
FreezeRef
LdU64(0)
VecImmBorrow(15)
ImmBorrowField[6](Price.conversion_rate: u64)
ReadRef
Sub
CopyLoc[0](Arg0: &mut DeepPrice)
MutBorrowField[4](DeepPrice.cumulative_base: u64)
WriteRef
CopyLoc[10](loc6: &mut vector<Price>)
LdU64(0)
Call vector::remove<Price>(&mut vector<Price>, u64): Price
Pop
Branch(46)
B13:
MoveLoc[0](Arg0: &mut DeepPrice)
Pop
MoveLoc[10](loc6: &mut vector<Price>)
Pop
Branch(147)
B14:
CopyLoc[0](Arg0: &mut DeepPrice)
ImmBorrowField[7](DeepPrice.cumulative_quote: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Add
CopyLoc[0](Arg0: &mut DeepPrice)
MutBorrowField[7](DeepPrice.cumulative_quote: u64)
WriteRef
B15:
CopyLoc[10](loc6: &mut vector<Price>)
FreezeRef
VecLen(15)
LdConst[4](u64: 100)
LdU64(1)
Add
Eq
BrFalse(112)
B16:
LdTrue
StLoc[9](loc5: bool)
Branch(123)
B17:
CopyLoc[10](loc6: &mut vector<Price>)
FreezeRef
LdU64(0)
VecImmBorrow(15)
ImmBorrowField[5](Price.timestamp: u64)
ReadRef
LdConst[3](u64: 8640..)
Add
CopyLoc[2](Arg2: u64)
Lt
StLoc[9](loc5: bool)
B18:
MoveLoc[9](loc5: bool)
BrFalse(143)
B19:
CopyLoc[0](Arg0: &mut DeepPrice)
ImmBorrowField[7](DeepPrice.cumulative_quote: u64)
ReadRef
CopyLoc[10](loc6: &mut vector<Price>)
FreezeRef
LdU64(0)
VecImmBorrow(15)
ImmBorrowField[6](Price.conversion_rate: u64)
ReadRef
Sub
CopyLoc[0](Arg0: &mut DeepPrice)
MutBorrowField[7](DeepPrice.cumulative_quote: u64)
WriteRef
CopyLoc[10](loc6: &mut vector<Price>)
LdU64(0)
Call vector::remove<Price>(&mut vector<Price>, u64): Price
Pop
Branch(101)
B20:
MoveLoc[0](Arg0: &mut DeepPrice)
Pop
MoveLoc[10](loc6: &mut vector<Price>)
Pop
B21:
Ret
}
public(friend) emit_deep_price_added(Arg0: u64, Arg1: u64, Arg2: bool, Arg3: ID, Arg4: ID) {
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: bool)
MoveLoc[3](Arg3: ID)
MoveLoc[4](Arg4: ID)
Pack[1](PriceAdded)
Call event::emit<PriceAdded>(PriceAdded)
Ret
}
calculate_order_deep_price(Arg0: &DeepPrice, Arg1: bool): bool * u64 {
L2:	loc0: bool
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: bool
B0:
MoveLoc[1](Arg1: bool)
BrFalse(7)
B1:
MoveLoc[0](Arg0: &DeepPrice)
Pop
LdFalse
LdU64(0)
Ret
B2:
CopyLoc[0](Arg0: &DeepPrice)
LdTrue
Call last_insert_timestamp(&DeepPrice, bool): u64
LdU64(0)
Gt
BrFalse(16)
B3:
LdTrue
StLoc[2](loc0: bool)
Branch(22)
B4:
CopyLoc[0](Arg0: &DeepPrice)
LdFalse
Call last_insert_timestamp(&DeepPrice, bool): u64
LdU64(0)
Gt
StLoc[2](loc0: bool)
B5:
MoveLoc[2](loc0: bool)
BrFalse(25)
B6:
Branch(29)
B7:
MoveLoc[0](Arg0: &DeepPrice)
Pop
LdConst[1](u64: 2)
Abort
B8:
CopyLoc[0](Arg0: &DeepPrice)
LdFalse
Call last_insert_timestamp(&DeepPrice, bool): u64
LdU64(0)
Eq
StLoc[8](loc6: bool)
CopyLoc[8](loc6: bool)
BrFalse(42)
B9:
CopyLoc[0](Arg0: &DeepPrice)
ImmBorrowField[4](DeepPrice.cumulative_base: u64)
ReadRef
StLoc[3](loc1: u64)
Branch(46)
B10:
CopyLoc[0](Arg0: &DeepPrice)
ImmBorrowField[7](DeepPrice.cumulative_quote: u64)
ReadRef
StLoc[3](loc1: u64)
B11:
MoveLoc[3](loc1: u64)
StLoc[6](loc4: u64)
CopyLoc[8](loc6: bool)
BrFalse(55)
B12:
MoveLoc[0](Arg0: &DeepPrice)
ImmBorrowField[2](DeepPrice.base_prices: vector<Price>)
VecLen(15)
StLoc[4](loc2: u64)
Branch(59)
B13:
MoveLoc[0](Arg0: &DeepPrice)
ImmBorrowField[3](DeepPrice.quote_prices: vector<Price>)
VecLen(15)
StLoc[4](loc2: u64)
B14:
MoveLoc[4](loc2: u64)
StLoc[5](loc3: u64)
MoveLoc[6](loc4: u64)
MoveLoc[5](loc3: u64)
Div
StLoc[7](loc5: u64)
MoveLoc[8](loc6: bool)
MoveLoc[7](loc5: u64)
Ret
}
last_insert_timestamp(Arg0: &DeepPrice, Arg1: bool): u64 {
L2:	loc0: &vector<Price>
L3:	loc1: u64
L4:	loc2: &vector<Price>
B0:
MoveLoc[1](Arg1: bool)
BrFalse(6)
B1:
MoveLoc[0](Arg0: &DeepPrice)
ImmBorrowField[2](DeepPrice.base_prices: vector<Price>)
StLoc[2](loc0: &vector<Price>)
Branch(9)
B2:
MoveLoc[0](Arg0: &DeepPrice)
ImmBorrowField[3](DeepPrice.quote_prices: vector<Price>)
StLoc[2](loc0: &vector<Price>)
B3:
MoveLoc[2](loc0: &vector<Price>)
StLoc[4](loc2: &vector<Price>)
CopyLoc[4](loc2: &vector<Price>)
VecLen(15)
LdU64(0)
Gt
BrFalse(26)
B4:
CopyLoc[4](loc2: &vector<Price>)
MoveLoc[4](loc2: &vector<Price>)
VecLen(15)
LdU64(1)
Sub
VecImmBorrow(15)
ImmBorrowField[5](Price.timestamp: u64)
ReadRef
StLoc[3](loc1: u64)
Branch(30)
B5:
MoveLoc[4](loc2: &vector<Price>)
Pop
LdU64(0)
StLoc[3](loc1: u64)
B6:
MoveLoc[3](loc1: u64)
Ret
}
Constants [
=> u64: 1
=> u64: 2
=> u64: 60000
=> u64: 86400000
=> u64: 100
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/governance.mvb755 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.governance {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::trade_params;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
struct Proposal has copy, drop, store {
	taker_fee: u64,
	maker_fee: u64,
	stake_required: u64,
	votes: u64
}
struct Governance has store {
	epoch: u64,
	whitelisted: bool,
	stable: bool,
	proposals: VecMap<ID, Proposal>,
	trade_params: TradeParams,
	next_trade_params: TradeParams,
	voting_power: u64,
	quorum: u64
}
struct TradeParamsUpdateEvent has copy, drop {
	taker_fee: u64,
	maker_fee: u64,
	stake_required: u64
}
public(friend) empty(Arg0: bool, Arg1: &TxContext): Governance {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u64
B0:
CopyLoc[0](Arg0: bool)
BrFalse(5)
B1:
LdConst[7](u64: 100000)
StLoc[2](loc0: u64)
Branch(7)
B2:
LdConst[10](u64: 1000..)
StLoc[2](loc0: u64)
B3:
MoveLoc[2](loc0: u64)
StLoc[5](loc3: u64)
CopyLoc[0](Arg0: bool)
BrFalse(14)
B4:
LdConst[9](u64: 50000)
StLoc[3](loc1: u64)
Branch(16)
B5:
LdConst[11](u64: 500000)
StLoc[3](loc1: u64)
B6:
MoveLoc[3](loc1: u64)
StLoc[4](loc2: u64)
MoveLoc[1](Arg1: &TxContext)
Call tx_context::epoch(&TxContext): u64
LdFalse
MoveLoc[0](Arg0: bool)
Call vec_map::empty<ID, Proposal>(): VecMap<ID, Proposal>
CopyLoc[5](loc3: u64)
CopyLoc[4](loc2: u64)
Call constants::default_stake_required(): u64
Call trade_params::new(u64, u64, u64): TradeParams
MoveLoc[5](loc3: u64)
MoveLoc[4](loc2: u64)
Call constants::default_stake_required(): u64
Call trade_params::new(u64, u64, u64): TradeParams
LdU64(0)
LdU64(0)
Pack[1](Governance)
Ret
}
public(friend) set_whitelist(Arg0: &mut Governance, Arg1: bool) {
B0:
MoveLoc[1](Arg1: bool)
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[0](Governance.whitelisted: bool)
WriteRef
MoveLoc[0](Arg0: &mut Governance)
Call reset_trade_params(&mut Governance)
Ret
}
public(friend) whitelisted(Arg0: &Governance): bool {
B0:
MoveLoc[0](Arg0: &Governance)
ImmBorrowField[0](Governance.whitelisted: bool)
ReadRef
Ret
}
public(friend) stable(Arg0: &Governance): bool {
B0:
MoveLoc[0](Arg0: &Governance)
ImmBorrowField[1](Governance.stable: bool)
ReadRef
Ret
}
public(friend) quorum(Arg0: &Governance): u64 {
B0:
MoveLoc[0](Arg0: &Governance)
ImmBorrowField[2](Governance.quorum: u64)
ReadRef
Ret
}
public(friend) update(Arg0: &mut Governance, Arg1: &TxContext) {
L2:	loc0: u64
B0:
MoveLoc[1](Arg1: &TxContext)
Call tx_context::epoch(&TxContext): u64
StLoc[2](loc0: u64)
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[3](Governance.epoch: u64)
ReadRef
CopyLoc[2](loc0: u64)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &mut Governance)
Pop
Ret
B2:
MoveLoc[2](loc0: u64)
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[3](Governance.epoch: u64)
WriteRef
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[4](Governance.voting_power: u64)
ReadRef
Call constants::half(): u64
Call math::mul(u64, u64): u64
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[2](Governance.quorum: u64)
WriteRef
Call vec_map::empty<ID, Proposal>(): VecMap<ID, Proposal>
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
WriteRef
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[6](Governance.next_trade_params: TradeParams)
ReadRef
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[7](Governance.trade_params: TradeParams)
WriteRef
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
MoveLoc[0](Arg0: &mut Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
Pack[2](TradeParamsUpdateEvent)
Call event::emit<TradeParamsUpdateEvent>(TradeParamsUpdateEvent)
Ret
}
public(friend) add_proposal(Arg0: &mut Governance, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: ID) {
L6:	loc0: bool
L7:	loc1: bool
L8:	loc2: bool
L9:	loc3: bool
L10:	loc4: Proposal
L11:	loc5: u64
B0:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[0](Governance.whitelisted: bool)
ReadRef
Not
BrFalse(6)
B1:
Branch(10)
B2:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[4](u64: 5)
Abort
B3:
CopyLoc[1](Arg1: u64)
LdConst[5](u64: 1000)
Mod
LdU64(0)
Eq
BrFalse(17)
B4:
Branch(21)
B5:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[1](u64: 2)
Abort
B6:
CopyLoc[2](Arg2: u64)
LdConst[5](u64: 1000)
Mod
LdU64(0)
Eq
BrFalse(28)
B7:
Branch(32)
B8:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[0](u64: 1)
Abort
B9:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[1](Governance.stable: bool)
ReadRef
BrFalse(72)
B10:
CopyLoc[1](Arg1: u64)
LdConst[6](u64: 10000)
Ge
BrFalse(45)
B11:
CopyLoc[1](Arg1: u64)
LdConst[7](u64: 100000)
Le
StLoc[6](loc0: bool)
Branch(47)
B12:
LdFalse
StLoc[6](loc0: bool)
B13:
MoveLoc[6](loc0: bool)
BrFalse(50)
B14:
Branch(54)
B15:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[1](u64: 2)
Abort
B16:
CopyLoc[2](Arg2: u64)
LdConst[8](u64: 0)
Ge
BrFalse(63)
B17:
CopyLoc[2](Arg2: u64)
LdConst[9](u64: 50000)
Le
StLoc[7](loc1: bool)
Branch(65)
B18:
LdFalse
StLoc[7](loc1: bool)
B19:
MoveLoc[7](loc1: bool)
BrFalse(68)
B20:
Branch(108)
B21:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[0](u64: 1)
Abort
B22:
CopyLoc[1](Arg1: u64)
LdConst[7](u64: 100000)
Ge
BrFalse(81)
B23:
CopyLoc[1](Arg1: u64)
LdConst[10](u64: 1000..)
Le
StLoc[8](loc2: bool)
Branch(83)
B24:
LdFalse
StLoc[8](loc2: bool)
B25:
MoveLoc[8](loc2: bool)
BrFalse(86)
B26:
Branch(90)
B27:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[1](u64: 2)
Abort
B28:
CopyLoc[2](Arg2: u64)
LdConst[8](u64: 0)
Ge
BrFalse(99)
B29:
CopyLoc[2](Arg2: u64)
LdConst[11](u64: 500000)
Le
StLoc[9](loc3: bool)
Branch(101)
B30:
LdFalse
StLoc[9](loc3: bool)
B31:
MoveLoc[9](loc3: bool)
BrFalse(104)
B32:
Branch(108)
B33:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[0](u64: 1)
Abort
B34:
MoveLoc[4](Arg4: u64)
Call stake_to_voting_power(u64): u64
StLoc[11](loc5: u64)
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
Call vec_map::size<ID, Proposal>(&VecMap<ID, Proposal>): u64
LdConst[12](u64: 100)
Eq
BrFalse(120)
B35:
CopyLoc[0](Arg0: &mut Governance)
MoveLoc[11](loc5: u64)
Call remove_lowest_proposal(&mut Governance, u64)
B36:
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
MoveLoc[3](Arg3: u64)
Call new_proposal(u64, u64, u64): Proposal
StLoc[10](loc4: Proposal)
MoveLoc[0](Arg0: &mut Governance)
MutBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
MoveLoc[5](Arg5: ID)
MoveLoc[10](loc4: Proposal)
Call vec_map::insert<ID, Proposal>(&mut VecMap<ID, Proposal>, ID, Proposal)
Ret
}
public(friend) adjust_vote(Arg0: &mut Governance, Arg1: Option<ID>, Arg2: Option<ID>, Arg3: u64) {
L4:	loc0: bool
L5:	loc1: bool
L6:	loc2: &Option<ID>
L7:	loc3: &mut Proposal
L8:	loc4: &mut Proposal
L9:	loc5: &ID
L10:	loc6: u64
B0:
MoveLoc[3](Arg3: u64)
Call stake_to_voting_power(u64): u64
StLoc[10](loc6: u64)
ImmBorrowLoc[1](Arg1: Option<ID>)
Call option::is_some<ID>(&Option<ID>): bool
BrFalse(13)
B1:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
ImmBorrowLoc[1](Arg1: Option<ID>)
Call option::borrow<ID>(&Option<ID>): &ID
Call vec_map::contains<ID, Proposal>(&VecMap<ID, Proposal>, &ID): bool
StLoc[4](loc0: bool)
Branch(15)
B2:
LdFalse
StLoc[4](loc0: bool)
B3:
MoveLoc[4](loc0: bool)
BrFalse(62)
B4:
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
ImmBorrowLoc[1](Arg1: Option<ID>)
Call option::borrow<ID>(&Option<ID>): &ID
Call vec_map::get_mut<ID, Proposal>(&mut VecMap<ID, Proposal>, &ID): &mut Proposal
StLoc[7](loc3: &mut Proposal)
CopyLoc[7](loc3: &mut Proposal)
ImmBorrowField[8](Proposal.votes: u64)
ReadRef
CopyLoc[10](loc6: u64)
Sub
CopyLoc[7](loc3: &mut Proposal)
MutBorrowField[8](Proposal.votes: u64)
WriteRef
CopyLoc[7](loc3: &mut Proposal)
ImmBorrowField[8](Proposal.votes: u64)
ReadRef
CopyLoc[10](loc6: u64)
Add
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[2](Governance.quorum: u64)
ReadRef
Gt
BrFalse(50)
B5:
MoveLoc[7](loc3: &mut Proposal)
ImmBorrowField[8](Proposal.votes: u64)
ReadRef
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[2](Governance.quorum: u64)
ReadRef
Lt
StLoc[5](loc1: bool)
Branch(54)
B6:
MoveLoc[7](loc3: &mut Proposal)
Pop
LdFalse
StLoc[5](loc1: bool)
B7:
MoveLoc[5](loc1: bool)
BrFalse(62)
B8:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
ReadRef
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[6](Governance.next_trade_params: TradeParams)
WriteRef
B9:
ImmBorrowLoc[2](Arg2: Option<ID>)
StLoc[6](loc2: &Option<ID>)
CopyLoc[6](loc2: &Option<ID>)
Call option::is_some<ID>(&Option<ID>): bool
BrFalse(115)
B10:
MoveLoc[6](loc2: &Option<ID>)
Call option::borrow<ID>(&Option<ID>): &ID
StLoc[9](loc5: &ID)
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
CopyLoc[9](loc5: &ID)
Call vec_map::contains<ID, Proposal>(&VecMap<ID, Proposal>, &ID): bool
BrFalse(76)
B11:
Branch(82)
B12:
MoveLoc[0](Arg0: &mut Governance)
Pop
MoveLoc[9](loc5: &ID)
Pop
LdConst[2](u64: 3)
Abort
B13:
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
MoveLoc[9](loc5: &ID)
Call vec_map::get_mut<ID, Proposal>(&mut VecMap<ID, Proposal>, &ID): &mut Proposal
StLoc[8](loc4: &mut Proposal)
CopyLoc[8](loc4: &mut Proposal)
ImmBorrowField[8](Proposal.votes: u64)
ReadRef
MoveLoc[10](loc6: u64)
Add
CopyLoc[8](loc4: &mut Proposal)
MutBorrowField[8](Proposal.votes: u64)
WriteRef
CopyLoc[8](loc4: &mut Proposal)
ImmBorrowField[8](Proposal.votes: u64)
ReadRef
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[2](Governance.quorum: u64)
ReadRef
Gt
BrFalse(110)
B14:
MoveLoc[8](loc4: &mut Proposal)
FreezeRef
Call to_trade_params(&Proposal): TradeParams
MoveLoc[0](Arg0: &mut Governance)
MutBorrowField[6](Governance.next_trade_params: TradeParams)
WriteRef
Branch(119)
B15:
MoveLoc[0](Arg0: &mut Governance)
Pop
MoveLoc[8](loc4: &mut Proposal)
Pop
Branch(119)
B16:
MoveLoc[0](Arg0: &mut Governance)
Pop
MoveLoc[6](loc2: &Option<ID>)
Pop
B17:
Ret
}
public(friend) adjust_voting_power(Arg0: &mut Governance, Arg1: u64, Arg2: u64) {
B0:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[4](Governance.voting_power: u64)
ReadRef
MoveLoc[2](Arg2: u64)
Call stake_to_voting_power(u64): u64
Add
MoveLoc[1](Arg1: u64)
Call stake_to_voting_power(u64): u64
Sub
MoveLoc[0](Arg0: &mut Governance)
MutBorrowField[4](Governance.voting_power: u64)
WriteRef
Ret
}
public(friend) trade_params(Arg0: &Governance): TradeParams {
B0:
MoveLoc[0](Arg0: &Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
ReadRef
Ret
}
public(friend) next_trade_params(Arg0: &Governance): TradeParams {
B0:
MoveLoc[0](Arg0: &Governance)
ImmBorrowField[6](Governance.next_trade_params: TradeParams)
ReadRef
Ret
}
stake_to_voting_power(Arg0: u64): u64 {
L1:	loc0: u64
B0:
CopyLoc[0](Arg0: u64)
LdConst[13](u64: 1000..)
Call u64::min(u64, u64): u64
StLoc[1](loc0: u64)
CopyLoc[0](Arg0: u64)
LdConst[13](u64: 1000..)
Gt
BrFalse(18)
B1:
MoveLoc[1](loc0: u64)
MoveLoc[0](Arg0: u64)
Call constants::deep_unit(): u64
Call math::sqrt(u64, u64): u64
Add
LdConst[13](u64: 1000..)
Call constants::deep_unit(): u64
Call math::sqrt(u64, u64): u64
Sub
StLoc[1](loc0: u64)
B2:
MoveLoc[1](loc0: u64)
Ret
}
new_proposal(Arg0: u64, Arg1: u64, Arg2: u64): Proposal {
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
LdU64(0)
Pack[0](Proposal)
Ret
}
remove_lowest_proposal(Arg0: &mut Governance, Arg1: u64) {
L2:	loc0: u64
L3:	loc1: bool
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: vector<ID>
L8:	loc6: u64
L9:	loc7: Option<ID>
L10:	loc8: u64
L11:	loc9: vector<Proposal>
B0:
Call option::none<ID>(): Option<ID>
StLoc[9](loc7: Option<ID>)
Call constants::max_u64(): u64
StLoc[4](loc2: u64)
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
ReadRef
Call vec_map::into_keys_values<ID, Proposal>(VecMap<ID, Proposal>): vector<ID> * vector<Proposal>
StLoc[11](loc9: vector<Proposal>)
StLoc[7](loc5: vector<ID>)
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
Call vec_map::size<ID, Proposal>(&VecMap<ID, Proposal>): u64
StLoc[2](loc0: u64)
LdU64(0)
StLoc[5](loc3: u64)
MoveLoc[2](loc0: u64)
StLoc[10](loc8: u64)
B1:
CopyLoc[5](loc3: u64)
CopyLoc[10](loc8: u64)
Lt
BrFalse(57)
B2:
CopyLoc[5](loc3: u64)
StLoc[6](loc4: u64)
ImmBorrowLoc[11](loc9: vector<Proposal>)
CopyLoc[6](loc4: u64)
VecImmBorrow(13)
ImmBorrowField[8](Proposal.votes: u64)
ReadRef
StLoc[8](loc6: u64)
CopyLoc[8](loc6: u64)
CopyLoc[1](Arg1: u64)
Lt
BrFalse(39)
B3:
CopyLoc[8](loc6: u64)
CopyLoc[4](loc2: u64)
Le
StLoc[3](loc1: bool)
Branch(42)
B4:
LdFalse
StLoc[3](loc1: bool)
Branch(42)
B5:
MoveLoc[3](loc1: bool)
BrFalse(52)
B6:
ImmBorrowLoc[7](loc5: vector<ID>)
MoveLoc[6](loc4: u64)
VecImmBorrow(29)
ReadRef
Call option::some<ID>(ID): Option<ID>
StLoc[9](loc7: Option<ID>)
MoveLoc[8](loc6: u64)
StLoc[4](loc2: u64)
B7:
MoveLoc[5](loc3: u64)
LdU64(1)
Add
StLoc[5](loc3: u64)
Branch(18)
B8:
ImmBorrowLoc[9](loc7: Option<ID>)
Call option::is_some<ID>(&Option<ID>): bool
BrFalse(61)
B9:
Branch(65)
B10:
MoveLoc[0](Arg0: &mut Governance)
Pop
LdConst[3](u64: 4)
Abort
B11:
MoveLoc[0](Arg0: &mut Governance)
MutBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
ImmBorrowLoc[9](loc7: Option<ID>)
Call option::borrow<ID>(&Option<ID>): &ID
Call vec_map::remove<ID, Proposal>(&mut VecMap<ID, Proposal>, &ID): ID * Proposal
Pop
Pop
Ret
}
reset_trade_params(Arg0: &mut Governance) {
L1:	loc0: u64
B0:
Call vec_map::empty<ID, Proposal>(): VecMap<ID, Proposal>
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[5](Governance.proposals: VecMap<ID, Proposal>)
WriteRef
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
StLoc[1](loc0: u64)
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[0](Governance.whitelisted: bool)
ReadRef
BrFalse(20)
B1:
LdU64(0)
LdU64(0)
LdU64(0)
Call trade_params::new(u64, u64, u64): TradeParams
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[7](Governance.trade_params: TradeParams)
WriteRef
Branch(39)
B2:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[1](Governance.stable: bool)
ReadRef
BrFalse(32)
B3:
LdConst[7](u64: 100000)
LdConst[9](u64: 50000)
MoveLoc[1](loc0: u64)
Call trade_params::new(u64, u64, u64): TradeParams
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[7](Governance.trade_params: TradeParams)
WriteRef
Branch(39)
B4:
LdConst[10](u64: 1000..)
LdConst[11](u64: 500000)
MoveLoc[1](loc0: u64)
Call trade_params::new(u64, u64, u64): TradeParams
CopyLoc[0](Arg0: &mut Governance)
MutBorrowField[7](Governance.trade_params: TradeParams)
WriteRef
B5:
CopyLoc[0](Arg0: &mut Governance)
ImmBorrowField[7](Governance.trade_params: TradeParams)
ReadRef
MoveLoc[0](Arg0: &mut Governance)
MutBorrowField[6](Governance.next_trade_params: TradeParams)
WriteRef
Ret
}
to_trade_params(Arg0: &Proposal): TradeParams {
B0:
CopyLoc[0](Arg0: &Proposal)
ImmBorrowField[9](Proposal.taker_fee: u64)
ReadRef
CopyLoc[0](Arg0: &Proposal)
ImmBorrowField[10](Proposal.maker_fee: u64)
ReadRef
MoveLoc[0](Arg0: &Proposal)
ImmBorrowField[11](Proposal.stake_required: u64)
ReadRef
Call trade_params::new(u64, u64, u64): TradeParams
Ret
}
Constants [
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 1000
=> u64: 10000
=> u64: 100000
=> u64: 0
=> u64: 50000
=> u64: 1000000
=> u64: 500000
=> u64: 100
=> u64: 100000000000
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/history.mvb509 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.history {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::trade_params;
use 0000000000000000000000000000000000000000000000000000000000000001::u128;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct Volumes has copy, drop, store {
	total_volume: u128,
	total_staked_volume: u128,
	total_fees_collected: Balances,
	historic_median: u128,
	trade_params: TradeParams
}
struct History has store {
	epoch: u64,
	epoch_created: u64,
	volumes: Volumes,
	historic_volumes: Table<u64, Volumes>,
	balance_to_burn: u64
}
struct EpochData has copy, drop, store {
	epoch: u64,
	pool_id: ID,
	total_volume: u128,
	total_staked_volume: u128,
	base_fees_collected: u64,
	quote_fees_collected: u64,
	deep_fees_collected: u64,
	historic_median: u128,
	taker_fee: u64,
	maker_fee: u64,
	stake_required: u64
}
public(friend) empty(Arg0: TradeParams, Arg1: u64, Arg2: &mut TxContext): History {
L3:	loc0: History
L4:	loc1: Volumes
B0:
LdU128(0)
LdU128(0)
Call balances::empty(): Balances
LdU128(0)
MoveLoc[0](Arg0: TradeParams)
Pack[0](Volumes)
StLoc[4](loc1: Volumes)
CopyLoc[2](Arg2: &mut TxContext)
FreezeRef
Call tx_context::epoch(&TxContext): u64
MoveLoc[1](Arg1: u64)
CopyLoc[4](loc1: Volumes)
CopyLoc[2](Arg2: &mut TxContext)
Call table::new<u64, Volumes>(&mut TxContext): Table<u64, Volumes>
LdU64(0)
Pack[1](History)
StLoc[3](loc0: History)
MutBorrowLoc[3](loc0: History)
MutBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
MoveLoc[2](Arg2: &mut TxContext)
FreezeRef
Call tx_context::epoch(&TxContext): u64
MoveLoc[4](loc1: Volumes)
Call table::add<u64, Volumes>(&mut Table<u64, Volumes>, u64, Volumes)
MoveLoc[3](loc0: History)
Ret
}
public(friend) update(Arg0: &mut History, Arg1: TradeParams, Arg2: ID, Arg3: &TxContext) {
L4:	loc0: u64
B0:
MoveLoc[3](Arg3: &TxContext)
Call tx_context::epoch(&TxContext): u64
StLoc[4](loc0: u64)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
CopyLoc[4](loc0: u64)
Eq
BrFalse(12)
B1:
MoveLoc[0](Arg0: &mut History)
Pop
Ret
B2:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
Call table::contains<u64, Volumes>(&Table<u64, Volumes>, u64): bool
BrFalse(26)
B3:
CopyLoc[0](Arg0: &mut History)
MutBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
Call table::remove<u64, Volumes>(&mut Table<u64, Volumes>, u64): Volumes
Pop
B4:
CopyLoc[0](Arg0: &mut History)
Call update_historic_median(&mut History)
CopyLoc[0](Arg0: &mut History)
MutBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ReadRef
Call table::add<u64, Volumes>(&mut Table<u64, Volumes>, u64, Volumes)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
MoveLoc[2](Arg2: ID)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[3](Volumes.total_volume: u128)
ReadRef
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[4](Volumes.total_staked_volume: u128)
ReadRef
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[5](Volumes.total_fees_collected: Balances)
Call balances::base(&Balances): u64
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[5](Volumes.total_fees_collected: Balances)
Call balances::quote(&Balances): u64
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[5](Volumes.total_fees_collected: Balances)
Call balances::deep(&Balances): u64
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[6](Volumes.historic_median: u128)
ReadRef
ImmBorrowLoc[1](Arg1: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
ImmBorrowLoc[1](Arg1: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
ImmBorrowLoc[1](Arg1: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
Pack[2](EpochData)
Call event::emit<EpochData>(EpochData)
MoveLoc[4](loc0: u64)
CopyLoc[0](Arg0: &mut History)
MutBorrowField[1](History.epoch: u64)
WriteRef
CopyLoc[0](Arg0: &mut History)
MoveLoc[1](Arg1: TradeParams)
Call reset_volumes(&mut History, TradeParams)
CopyLoc[0](Arg0: &mut History)
MutBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
MoveLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ReadRef
Call table::add<u64, Volumes>(&mut Table<u64, Volumes>, u64, Volumes)
Ret
}
public(friend) reset_volumes(Arg0: &mut History, Arg1: TradeParams) {
B0:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ReadRef
Call event::emit<Volumes>(Volumes)
LdU128(0)
LdU128(0)
Call balances::empty(): Balances
LdU128(0)
MoveLoc[1](Arg1: TradeParams)
Pack[0](Volumes)
MoveLoc[0](Arg0: &mut History)
MutBorrowField[2](History.volumes: Volumes)
WriteRef
Ret
}
public(friend) calculate_rebate_amount(Arg0: &mut History, Arg1: u64, Arg2: u128, Arg3: u64): Balances {
L4:	loc0: u128
L5:	loc1: u64
L6:	loc2: u64
L7:	loc3: u64
L8:	loc4: u128
L9:	loc5: u64
L10:	loc6: Balances
L11:	loc7: u128
L12:	loc8: Balances
L13:	loc9: &mut Volumes
B0:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[1](Arg1: u64)
Call table::contains<u64, Volumes>(&Table<u64, Volumes>, u64): bool
BrFalse(6)
B1:
Branch(10)
B2:
MoveLoc[0](Arg0: &mut History)
Pop
LdConst[0](u64: 0)
Abort
B3:
CopyLoc[0](Arg0: &mut History)
MutBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
MoveLoc[1](Arg1: u64)
Call table::borrow_mut<u64, Volumes>(&mut Table<u64, Volumes>, u64): &mut Volumes
StLoc[13](loc9: &mut Volumes)
CopyLoc[13](loc9: &mut Volumes)
ImmBorrowField[7](Volumes.trade_params: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
MoveLoc[3](Arg3: u64)
Gt
BrFalse(27)
B4:
MoveLoc[13](loc9: &mut Volumes)
Pop
MoveLoc[0](Arg0: &mut History)
Pop
Call balances::empty(): Balances
Ret
B5:
MoveLoc[2](Arg2: u128)
CastU128
StLoc[8](loc4: u128)
CopyLoc[13](loc9: &mut Volumes)
ImmBorrowField[3](Volumes.total_volume: u128)
ReadRef
CopyLoc[8](loc4: u128)
Sub
StLoc[11](loc7: u128)
CopyLoc[13](loc9: &mut Volumes)
ImmBorrowField[6](Volumes.historic_median: u128)
ReadRef
LdU128(0)
Gt
BrFalse(53)
B6:
Call constants::float_scaling_u128(): u128
Call constants::float_scaling_u128(): u128
MoveLoc[11](loc7: u128)
CopyLoc[13](loc9: &mut Volumes)
ImmBorrowField[6](Volumes.historic_median: u128)
ReadRef
Call math::div_u128(u128, u128): u128
Call u128::min(u128, u128): u128
Sub
StLoc[4](loc0: u128)
Branch(55)
B7:
LdU128(0)
StLoc[4](loc0: u128)
B8:
MoveLoc[4](loc0: u128)
CastU64
StLoc[7](loc3: u64)
CopyLoc[13](loc9: &mut Volumes)
ImmBorrowField[4](Volumes.total_staked_volume: u128)
ReadRef
LdU128(0)
Gt
BrFalse(72)
B9:
MoveLoc[8](loc4: u128)
CopyLoc[13](loc9: &mut Volumes)
ImmBorrowField[4](Volumes.total_staked_volume: u128)
ReadRef
Call math::div_u128(u128, u128): u128
CastU64
StLoc[5](loc1: u64)
Branch(74)
B10:
LdU64(0)
StLoc[5](loc1: u64)
B11:
MoveLoc[5](loc1: u64)
StLoc[9](loc5: u64)
MoveLoc[13](loc9: &mut Volumes)
ImmBorrowField[5](Volumes.total_fees_collected: Balances)
ReadRef
StLoc[10](loc6: Balances)
MutBorrowLoc[10](loc6: Balances)
MoveLoc[9](loc5: u64)
Call balances::mul(&mut Balances, u64)
CopyLoc[10](loc6: Balances)
StLoc[12](loc8: Balances)
MutBorrowLoc[12](loc8: Balances)
MoveLoc[7](loc3: u64)
Call balances::mul(&mut Balances, u64)
ImmBorrowLoc[10](loc6: Balances)
Call balances::deep(&Balances): u64
ImmBorrowLoc[12](loc8: Balances)
Call balances::deep(&Balances): u64
Sub
StLoc[6](loc2: u64)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[8](History.balance_to_burn: u64)
ReadRef
MoveLoc[6](loc2: u64)
Add
MoveLoc[0](Arg0: &mut History)
MutBorrowField[8](History.balance_to_burn: u64)
WriteRef
MoveLoc[12](loc8: Balances)
Ret
}
public(friend) update_historic_median(Arg0: &mut History) {
L1:	loc0: u64
L2:	loc1: vector<u128>
B0:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[9](History.epoch_created: u64)
ReadRef
Sub
Call constants::phase_out_epochs(): u64
Lt
BrFalse(16)
B1:
Call constants::max_u128(): u128
MoveLoc[0](Arg0: &mut History)
MutBorrowField[2](History.volumes: Volumes)
MutBorrowField[6](Volumes.historic_median: u128)
WriteRef
Ret
B2:
LdConst[1](vector<u128>: 00)
StLoc[2](loc1: vector<u128>)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
Call constants::phase_out_epochs(): u64
Sub
StLoc[1](loc0: u64)
B3:
CopyLoc[1](loc0: u64)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[1](History.epoch: u64)
ReadRef
Lt
BrFalse(53)
B4:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[1](loc0: u64)
Call table::contains<u64, Volumes>(&Table<u64, Volumes>, u64): bool
BrFalse(45)
B5:
Branch(36)
B6:
MutBorrowLoc[2](loc1: vector<u128>)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[1](loc0: u64)
Call table::borrow<u64, Volumes>(&Table<u64, Volumes>, u64): &Volumes
ImmBorrowField[3](Volumes.total_volume: u128)
ReadRef
VecPushBack(30)
Branch(48)
B7:
MutBorrowLoc[2](loc1: vector<u128>)
LdU128(0)
VecPushBack(30)
B8:
MoveLoc[1](loc0: u64)
LdU64(1)
Add
StLoc[1](loc0: u64)
Branch(24)
B9:
MoveLoc[2](loc1: vector<u128>)
Call math::median(vector<u128>): u128
MoveLoc[0](Arg0: &mut History)
MutBorrowField[2](History.volumes: Volumes)
MutBorrowField[6](Volumes.historic_median: u128)
WriteRef
Ret
}
public(friend) add_volume(Arg0: &mut History, Arg1: u64, Arg2: u64) {
L3:	loc0: u128
B0:
CopyLoc[1](Arg1: u64)
LdU64(0)
Eq
BrFalse(7)
B1:
MoveLoc[0](Arg0: &mut History)
Pop
Ret
B2:
MoveLoc[1](Arg1: u64)
CastU128
StLoc[3](loc0: u128)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[3](Volumes.total_volume: u128)
ReadRef
CopyLoc[3](loc0: u128)
Add
CopyLoc[0](Arg0: &mut History)
MutBorrowField[2](History.volumes: Volumes)
MutBorrowField[3](Volumes.total_volume: u128)
WriteRef
MoveLoc[2](Arg2: u64)
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[7](Volumes.trade_params: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
Ge
BrFalse(38)
B3:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[2](History.volumes: Volumes)
ImmBorrowField[4](Volumes.total_staked_volume: u128)
ReadRef
MoveLoc[3](loc0: u128)
Add
MoveLoc[0](Arg0: &mut History)
MutBorrowField[2](History.volumes: Volumes)
MutBorrowField[4](Volumes.total_staked_volume: u128)
WriteRef
Branch(40)
B4:
MoveLoc[0](Arg0: &mut History)
Pop
B5:
Ret
}
public(friend) balance_to_burn(Arg0: &History): u64 {
B0:
MoveLoc[0](Arg0: &History)
ImmBorrowField[8](History.balance_to_burn: u64)
ReadRef
Ret
}
public(friend) reset_balance_to_burn(Arg0: &mut History): u64 {
L1:	loc0: u64
B0:
CopyLoc[0](Arg0: &mut History)
ImmBorrowField[8](History.balance_to_burn: u64)
ReadRef
StLoc[1](loc0: u64)
LdU64(0)
MoveLoc[0](Arg0: &mut History)
MutBorrowField[8](History.balance_to_burn: u64)
WriteRef
MoveLoc[1](loc0: u64)
Ret
}
public(friend) historic_maker_fee(Arg0: &History, Arg1: u64): u64 {
B0:
CopyLoc[0](Arg0: &History)
ImmBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
CopyLoc[1](Arg1: u64)
Call table::contains<u64, Volumes>(&Table<u64, Volumes>, u64): bool
BrFalse(6)
B1:
Branch(10)
B2:
MoveLoc[0](Arg0: &History)
Pop
LdConst[0](u64: 0)
Abort
B3:
MoveLoc[0](Arg0: &History)
ImmBorrowField[0](History.historic_volumes: Table<u64, Volumes>)
MoveLoc[1](Arg1: u64)
Call table::borrow<u64, Volumes>(&Table<u64, Volumes>, u64): &Volumes
ImmBorrowField[7](Volumes.trade_params: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
Ret
}
public(friend) add_total_fees_collected(Arg0: &mut History, Arg1: Balances) {
B0:
MoveLoc[0](Arg0: &mut History)
MutBorrowField[2](History.volumes: Volumes)
MutBorrowField[5](Volumes.total_fees_collected: Balances)
MoveLoc[1](Arg1: Balances)
Call balances::add_balances(&mut Balances, Balances)
Ret
}
Constants [
=> u64: 0
=> vector<u128>: 00
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/math.mvb472 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.math {
use 0000000000000000000000000000000000000000000000000000000000000001::u128;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
public(friend) mul(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
Call mul_internal(u64, u64): u64 * u64
StLoc[2](loc0: u64)
Pop
MoveLoc[2](loc0: u64)
Ret
}
public(friend) mul_u128(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
B0:
MoveLoc[0](Arg0: u128)
MoveLoc[1](Arg1: u128)
Call mul_internal_u128(u128, u128): u128 * u128
StLoc[2](loc0: u128)
Pop
MoveLoc[2](loc0: u128)
Ret
}
public(friend) mul_round_up(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
L3:	loc1: u64
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
Call mul_internal(u64, u64): u64 * u64
StLoc[3](loc1: u64)
StLoc[2](loc0: u64)
MoveLoc[3](loc1: u64)
MoveLoc[2](loc0: u64)
Add
Ret
}
public(friend) div(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
Call div_internal(u64, u64): u64 * u64
StLoc[2](loc0: u64)
Pop
MoveLoc[2](loc0: u64)
Ret
}
public(friend) div_u128(Arg0: u128, Arg1: u128): u128 {
L2:	loc0: u128
B0:
MoveLoc[0](Arg0: u128)
MoveLoc[1](Arg1: u128)
Call div_internal_u128(u128, u128): u128 * u128
StLoc[2](loc0: u128)
Pop
MoveLoc[2](loc0: u128)
Ret
}
public(friend) div_round_up(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u64
L3:	loc1: u64
B0:
MoveLoc[0](Arg0: u64)
MoveLoc[1](Arg1: u64)
Call div_internal(u64, u64): u64 * u64
StLoc[3](loc1: u64)
StLoc[2](loc0: u64)
MoveLoc[3](loc1: u64)
MoveLoc[2](loc0: u64)
Add
Ret
}
public(friend) median(Arg0: vector<u128>): u128 {
L1:	loc0: u128
L2:	loc1: u64
L3:	loc2: vector<u128>
B0:
ImmBorrowLoc[0](Arg0: vector<u128>)
VecLen(3)
StLoc[2](loc1: u64)
CopyLoc[2](loc1: u64)
LdU64(0)
Eq
BrFalse(9)
B1:
LdU128(0)
Ret
B2:
MoveLoc[0](Arg0: vector<u128>)
Call quick_sort(vector<u128>): vector<u128>
StLoc[3](loc2: vector<u128>)
CopyLoc[2](loc1: u64)
LdU64(2)
Mod
LdU64(0)
Eq
BrFalse(39)
B3:
ImmBorrowLoc[3](loc2: vector<u128>)
CopyLoc[2](loc1: u64)
LdU64(2)
Div
LdU64(1)
Sub
VecImmBorrow(3)
ReadRef
ImmBorrowLoc[3](loc2: vector<u128>)
MoveLoc[2](loc1: u64)
LdU64(2)
Div
VecImmBorrow(3)
ReadRef
Add
LdConst[1](u128: 1000..)
LdU128(2)
Div
Call mul_u128(u128, u128): u128
StLoc[1](loc0: u128)
Branch(46)
B4:
ImmBorrowLoc[3](loc2: vector<u128>)
MoveLoc[2](loc1: u64)
LdU64(2)
Div
VecImmBorrow(3)
ReadRef
StLoc[1](loc0: u128)
B5:
MoveLoc[1](loc0: u128)
Ret
}
public(friend) sqrt(Arg0: u64, Arg1: u64): u64 {
L2:	loc0: u128
B0:
CopyLoc[1](Arg1: u64)
LdConst[0](u64: 1000..)
Le
BrFalse(5)
B1:
Branch(7)
B2:
LdConst[3](u64: 0)
Abort
B3:
LdConst[0](u64: 1000..)
MoveLoc[1](Arg1: u64)
Div
CastU128
StLoc[2](loc0: u128)
MoveLoc[0](Arg0: u64)
CastU128
CopyLoc[2](loc0: u128)
Mul
LdConst[1](u128: 1000..)
Mul
Call u128::sqrt(u128): u128
MoveLoc[2](loc0: u128)
Div
CastU64
Ret
}
public(friend) is_power_of_ten(Arg0: u64): bool {
L1:	loc0: bool
L2:	loc1: u64
B0:
MoveLoc[0](Arg0: u64)
StLoc[2](loc1: u64)
CopyLoc[2](loc1: u64)
LdU64(1)
Lt
BrFalse(9)
B1:
LdFalse
StLoc[1](loc0: bool)
Branch(24)
B2:
CopyLoc[2](loc1: u64)
LdU64(10)
Mod
LdU64(0)
Eq
BrFalse(20)
B3:
MoveLoc[2](loc1: u64)
LdU64(10)
Div
StLoc[2](loc1: u64)
Branch(9)
B4:
MoveLoc[2](loc1: u64)
LdU64(1)
Eq
StLoc[1](loc0: bool)
B5:
MoveLoc[1](loc0: bool)
Ret
}
quick_sort(Arg0: vector<u128>): vector<u128> {
L1:	loc0: u64
L2:	loc1: vector<u128>
L3:	loc2: vector<u128>
L4:	loc3: u64
L5:	loc4: vector<u128>
L6:	loc5: u128
L7:	loc6: vector<u128>
L8:	loc7: u64
L9:	loc8: vector<u128>
L10:	loc9: u128
B0:
ImmBorrowLoc[0](Arg0: vector<u128>)
VecLen(3)
LdU64(1)
Le
BrFalse(7)
B1:
MoveLoc[0](Arg0: vector<u128>)
Ret
B2:
ImmBorrowLoc[0](Arg0: vector<u128>)
LdU64(0)
VecImmBorrow(3)
ReadRef
StLoc[6](loc5: u128)
LdConst[4](vector<u128>: 00)
StLoc[5](loc4: vector<u128>)
LdConst[4](vector<u128>: 00)
StLoc[2](loc1: vector<u128>)
LdConst[4](vector<u128>: 00)
StLoc[3](loc2: vector<u128>)
MoveLoc[0](Arg0: vector<u128>)
StLoc[9](loc8: vector<u128>)
MutBorrowLoc[9](loc8: vector<u128>)
Call vector::reverse<u128>(&mut vector<u128>)
ImmBorrowLoc[9](loc8: vector<u128>)
VecLen(3)
StLoc[1](loc0: u64)
LdU64(0)
StLoc[4](loc3: u64)
MoveLoc[1](loc0: u64)
StLoc[8](loc7: u64)
B3:
CopyLoc[4](loc3: u64)
CopyLoc[8](loc7: u64)
Lt
BrFalse(63)
B4:
CopyLoc[4](loc3: u64)
Pop
MutBorrowLoc[9](loc8: vector<u128>)
VecPopBack(3)
StLoc[10](loc9: u128)
CopyLoc[10](loc9: u128)
CopyLoc[6](loc5: u128)
Lt
BrFalse(46)
B5:
MutBorrowLoc[5](loc4: vector<u128>)
MoveLoc[10](loc9: u128)
VecPushBack(3)
Branch(58)
B6:
CopyLoc[10](loc9: u128)
CopyLoc[6](loc5: u128)
Eq
BrFalse(54)
B7:
MutBorrowLoc[2](loc1: vector<u128>)
MoveLoc[10](loc9: u128)
VecPushBack(3)
Branch(58)
B8:
MutBorrowLoc[3](loc2: vector<u128>)
MoveLoc[10](loc9: u128)
VecPushBack(3)
Branch(58)
B9:
MoveLoc[4](loc3: u64)
LdU64(1)
Add
StLoc[4](loc3: u64)
Branch(29)
B10:
MoveLoc[9](loc8: vector<u128>)
VecUnpack(3, 0)
LdConst[4](vector<u128>: 00)
StLoc[7](loc6: vector<u128>)
MutBorrowLoc[7](loc6: vector<u128>)
MoveLoc[5](loc4: vector<u128>)
Call quick_sort(vector<u128>): vector<u128>
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MutBorrowLoc[7](loc6: vector<u128>)
MoveLoc[2](loc1: vector<u128>)
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MutBorrowLoc[7](loc6: vector<u128>)
MoveLoc[3](loc2: vector<u128>)
Call quick_sort(vector<u128>): vector<u128>
Call vector::append<u128>(&mut vector<u128>, vector<u128>)
MoveLoc[7](loc6: vector<u128>)
Ret
}
mul_internal(Arg0: u64, Arg1: u64): u64 * u64 {
L2:	loc0: u64
L3:	loc1: u128
L4:	loc2: u128
B0:
MoveLoc[0](Arg0: u64)
CastU128
StLoc[3](loc1: u128)
MoveLoc[1](Arg1: u64)
CastU128
StLoc[4](loc2: u128)
CopyLoc[3](loc1: u128)
CopyLoc[4](loc2: u128)
Mul
LdConst[1](u128: 1000..)
Mod
LdU128(0)
Eq
BrFalse(17)
B1:
LdU64(0)
StLoc[2](loc0: u64)
Branch(19)
B2:
LdU64(1)
StLoc[2](loc0: u64)
B3:
MoveLoc[2](loc0: u64)
MoveLoc[3](loc1: u128)
MoveLoc[4](loc2: u128)
Mul
LdConst[1](u128: 1000..)
Div
CastU64
Ret
}
mul_internal_u128(Arg0: u128, Arg1: u128): u128 * u128 {
L2:	loc0: u128
L3:	loc1: u256
L4:	loc2: u256
B0:
MoveLoc[0](Arg0: u128)
CastU256
StLoc[3](loc1: u256)
MoveLoc[1](Arg1: u128)
CastU256
StLoc[4](loc2: u256)
CopyLoc[3](loc1: u256)
CopyLoc[4](loc2: u256)
Mul
LdConst[2](u256: 1000..)
Mod
LdU256(0)
Eq
BrFalse(17)
B1:
LdU128(0)
StLoc[2](loc0: u128)
Branch(19)
B2:
LdU128(1)
StLoc[2](loc0: u128)
B3:
MoveLoc[2](loc0: u128)
MoveLoc[3](loc1: u256)
MoveLoc[4](loc2: u256)
Mul
LdConst[2](u256: 1000..)
Div
CastU128
Ret
}
div_internal(Arg0: u64, Arg1: u64): u64 * u64 {
L2:	loc0: u64
L3:	loc1: u128
L4:	loc2: u128
B0:
MoveLoc[0](Arg0: u64)
CastU128
StLoc[3](loc1: u128)
MoveLoc[1](Arg1: u64)
CastU128
StLoc[4](loc2: u128)
CopyLoc[3](loc1: u128)
LdConst[1](u128: 1000..)
Mul
CopyLoc[4](loc2: u128)
Mod
LdU128(0)
Eq
BrFalse(17)
B1:
LdU64(0)
StLoc[2](loc0: u64)
Branch(19)
B2:
LdU64(1)
StLoc[2](loc0: u64)
B3:
MoveLoc[2](loc0: u64)
MoveLoc[3](loc1: u128)
LdConst[1](u128: 1000..)
Mul
MoveLoc[4](loc2: u128)
Div
CastU64
Ret
}
div_internal_u128(Arg0: u128, Arg1: u128): u128 * u128 {
L2:	loc0: u128
L3:	loc1: u256
L4:	loc2: u256
B0:
MoveLoc[0](Arg0: u128)
CastU256
StLoc[3](loc1: u256)
MoveLoc[1](Arg1: u128)
CastU256
StLoc[4](loc2: u256)
CopyLoc[3](loc1: u256)
LdConst[2](u256: 1000..)
Mul
CopyLoc[4](loc2: u256)
Mod
LdU256(0)
Eq
BrFalse(17)
B1:
LdU128(0)
StLoc[2](loc0: u128)
Branch(19)
B2:
LdU128(1)
StLoc[2](loc0: u128)
B3:
MoveLoc[2](loc0: u128)
MoveLoc[3](loc1: u256)
LdConst[2](u256: 1000..)
Mul
MoveLoc[4](loc2: u256)
Div
CastU128
Ret
}
Constants [
=> u64: 1000000000
=> u128: 1000000000
=> u256: 1000000000
=> u64: 0
=> vector<u128>: 00
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/order.mvb757 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.order {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::deep_price;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::fill;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
struct Order has drop, store {
	balance_manager_id: ID,
	order_id: u128,
	client_order_id: u64,
	quantity: u64,
	filled_quantity: u64,
	fee_is_deep: bool,
	order_deep_price: OrderDeepPrice,
	epoch: u64,
	status: u8,
	expire_timestamp: u64
}
struct OrderCanceled has copy, drop, store {
	balance_manager_id: ID,
	pool_id: ID,
	order_id: u128,
	client_order_id: u64,
	trader: address,
	price: u64,
	is_bid: bool,
	original_quantity: u64,
	base_asset_quantity_canceled: u64,
	timestamp: u64
}
struct OrderModified has copy, drop, store {
	balance_manager_id: ID,
	pool_id: ID,
	order_id: u128,
	client_order_id: u64,
	trader: address,
	price: u64,
	is_bid: bool,
	previous_quantity: u64,
	filled_quantity: u64,
	new_quantity: u64,
	timestamp: u64
}
public balance_manager_id(Arg0: &Order): ID {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[0](Order.balance_manager_id: ID)
ReadRef
Ret
}
public order_id(Arg0: &Order): u128 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
Ret
}
public client_order_id(Arg0: &Order): u64 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[2](Order.client_order_id: u64)
ReadRef
Ret
}
public quantity(Arg0: &Order): u64 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
Ret
}
public filled_quantity(Arg0: &Order): u64 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Ret
}
public fee_is_deep(Arg0: &Order): bool {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[5](Order.fee_is_deep: bool)
ReadRef
Ret
}
public order_deep_price(Arg0: &Order): &OrderDeepPrice {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[6](Order.order_deep_price: OrderDeepPrice)
Ret
}
public epoch(Arg0: &Order): u64 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[7](Order.epoch: u64)
ReadRef
Ret
}
public status(Arg0: &Order): u8 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[8](Order.status: u8)
ReadRef
Ret
}
public expire_timestamp(Arg0: &Order): u64 {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[9](Order.expire_timestamp: u64)
ReadRef
Ret
}
public price(Arg0: &Order): u64 {
L1:	loc0: u64
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
Call utils::decode_order_id(u128): bool * u64 * u64
Pop
StLoc[1](loc0: u64)
Pop
MoveLoc[1](loc0: u64)
Ret
}
public(friend) new(Arg0: u128, Arg1: ID, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: bool, Arg6: OrderDeepPrice, Arg7: u64, Arg8: u8, Arg9: u64): Order {
L10:	loc0: u128
L11:	loc1: u64
L12:	loc2: ID
L13:	loc3: u64
L14:	loc4: u64
L15:	loc5: u64
L16:	loc6: bool
L17:	loc7: OrderDeepPrice
L18:	loc8: u64
L19:	loc9: u8
B0:
MoveLoc[0](Arg0: u128)
StLoc[10](loc0: u128)
MoveLoc[1](Arg1: ID)
StLoc[12](loc2: ID)
MoveLoc[2](Arg2: u64)
StLoc[13](loc3: u64)
MoveLoc[3](Arg3: u64)
StLoc[14](loc4: u64)
MoveLoc[4](Arg4: u64)
StLoc[15](loc5: u64)
MoveLoc[5](Arg5: bool)
StLoc[16](loc6: bool)
MoveLoc[6](Arg6: OrderDeepPrice)
StLoc[17](loc7: OrderDeepPrice)
MoveLoc[7](Arg7: u64)
StLoc[18](loc8: u64)
MoveLoc[8](Arg8: u8)
StLoc[19](loc9: u8)
MoveLoc[9](Arg9: u64)
StLoc[11](loc1: u64)
MoveLoc[12](loc2: ID)
MoveLoc[10](loc0: u128)
MoveLoc[13](loc3: u64)
MoveLoc[14](loc4: u64)
MoveLoc[15](loc5: u64)
MoveLoc[16](loc6: bool)
MoveLoc[17](loc7: OrderDeepPrice)
MoveLoc[18](loc8: u64)
MoveLoc[19](loc9: u8)
MoveLoc[11](loc1: u64)
Pack[0](Order)
Ret
}
public(friend) generate_fill(Arg0: &mut Order, Arg1: u64, Arg2: u64, Arg3: bool, Arg4: bool, Arg5: bool): Fill {
L6:	loc0: bool
L7:	loc1: u8
L8:	loc2: ID
L9:	loc3: u64
L10:	loc4: bool
L11:	loc5: u128
L12:	loc6: u64
L13:	loc7: u64
B0:
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Sub
StLoc[13](loc7: u64)
CopyLoc[13](loc7: u64)
MoveLoc[2](Arg2: u64)
Call u64::min(u64, u64): u64
StLoc[9](loc3: u64)
CopyLoc[9](loc3: u64)
CopyLoc[0](Arg0: &mut Order)
FreezeRef
Call price(&Order): u64
Call math::mul(u64, u64): u64
StLoc[12](loc6: u64)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
StLoc[11](loc5: u128)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[0](Order.balance_manager_id: ID)
ReadRef
StLoc[8](loc2: ID)
MoveLoc[1](Arg1: u64)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[9](Order.expire_timestamp: u64)
ReadRef
Gt
BrFalse(35)
B1:
LdTrue
StLoc[6](loc0: bool)
Branch(37)
B2:
MoveLoc[4](Arg4: bool)
StLoc[6](loc0: bool)
B3:
MoveLoc[6](loc0: bool)
StLoc[10](loc4: bool)
CopyLoc[10](loc4: bool)
BrFalse(54)
B4:
Call constants::expired(): u8
CopyLoc[0](Arg0: &mut Order)
MutBorrowField[8](Order.status: u8)
WriteRef
MoveLoc[13](loc7: u64)
StLoc[9](loc3: u64)
CopyLoc[9](loc3: u64)
CopyLoc[0](Arg0: &mut Order)
FreezeRef
Call price(&Order): u64
Call math::mul(u64, u64): u64
StLoc[12](loc6: u64)
Branch(79)
B5:
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
CopyLoc[9](loc3: u64)
Add
CopyLoc[0](Arg0: &mut Order)
MutBorrowField[4](Order.filled_quantity: u64)
WriteRef
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Eq
BrFalse(73)
B6:
Call constants::filled(): u8
StLoc[7](loc1: u8)
Branch(75)
B7:
Call constants::partially_filled(): u8
StLoc[7](loc1: u8)
B8:
MoveLoc[7](loc1: u8)
CopyLoc[0](Arg0: &mut Order)
MutBorrowField[8](Order.status: u8)
WriteRef
B9:
MoveLoc[11](loc5: u128)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[2](Order.client_order_id: u64)
ReadRef
CopyLoc[0](Arg0: &mut Order)
FreezeRef
Call price(&Order): u64
MoveLoc[8](loc2: ID)
MoveLoc[10](loc4: bool)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Eq
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
MoveLoc[9](loc3: u64)
MoveLoc[12](loc6: u64)
MoveLoc[3](Arg3: bool)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[7](Order.epoch: u64)
ReadRef
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[6](Order.order_deep_price: OrderDeepPrice)
ReadRef
MoveLoc[5](Arg5: bool)
MoveLoc[0](Arg0: &mut Order)
ImmBorrowField[5](Order.fee_is_deep: bool)
ReadRef
Call fill::new(u128, u64, u64, ID, bool, bool, u64, u64, u64, bool, u64, OrderDeepPrice, bool, bool): Fill
Ret
}
public(friend) modify(Arg0: &mut Order, Arg1: u64, Arg2: u64) {
L3:	loc0: bool
B0:
CopyLoc[1](Arg1: u64)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Gt
BrFalse(13)
B1:
CopyLoc[1](Arg1: u64)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
Lt
StLoc[3](loc0: bool)
Branch(15)
B2:
LdFalse
StLoc[3](loc0: bool)
B3:
MoveLoc[3](loc0: bool)
BrFalse(18)
B4:
Branch(22)
B5:
MoveLoc[0](Arg0: &mut Order)
Pop
LdConst[0](u64: 0)
Abort
B6:
MoveLoc[2](Arg2: u64)
CopyLoc[0](Arg0: &mut Order)
ImmBorrowField[9](Order.expire_timestamp: u64)
ReadRef
Le
BrFalse(29)
B7:
Branch(33)
B8:
MoveLoc[0](Arg0: &mut Order)
Pop
LdConst[1](u64: 1)
Abort
B9:
MoveLoc[1](Arg1: u64)
MoveLoc[0](Arg0: &mut Order)
MutBorrowField[3](Order.quantity: u64)
WriteRef
Ret
}
public(friend) calculate_cancel_refund(Arg0: &Order, Arg1: u64, Arg2: Option<u64>): Balances {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: Balances
L6:	loc3: u64
L7:	loc4: Balances
B0:
ImmBorrowLoc[2](Arg2: Option<u64>)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
CopyLoc[0](Arg0: &Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Sub
Call option::get_with_default<u64>(&Option<u64>, u64): u64
StLoc[4](loc1: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[6](Order.order_deep_price: OrderDeepPrice)
CopyLoc[4](loc1: u64)
CopyLoc[4](loc1: u64)
CopyLoc[0](Arg0: &Order)
Call price(&Order): u64
Call math::mul(u64, u64): u64
CopyLoc[0](Arg0: &Order)
Call is_bid(&Order): bool
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[5](loc2: Balances)
MutBorrowLoc[5](loc2: Balances)
MoveLoc[1](Arg1: u64)
Call balances::mul(&mut Balances, u64)
LdU64(0)
StLoc[3](loc0: u64)
LdU64(0)
StLoc[6](loc3: u64)
CopyLoc[0](Arg0: &Order)
Call is_bid(&Order): bool
BrFalse(37)
B1:
MoveLoc[4](loc1: u64)
MoveLoc[0](Arg0: &Order)
Call price(&Order): u64
Call math::mul(u64, u64): u64
StLoc[6](loc3: u64)
Branch(41)
B2:
MoveLoc[0](Arg0: &Order)
Pop
MoveLoc[4](loc1: u64)
StLoc[3](loc0: u64)
B3:
MoveLoc[3](loc0: u64)
MoveLoc[6](loc3: u64)
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[7](loc4: Balances)
MutBorrowLoc[7](loc4: Balances)
MoveLoc[5](loc2: Balances)
Call balances::add_balances(&mut Balances, Balances)
MoveLoc[7](loc4: Balances)
Ret
}
public(friend) locked_balance(Arg0: &Order, Arg1: u64): Balances {
L2:	loc0: u64
L3:	loc1: Balances
L4:	loc2: bool
L5:	loc3: Balances
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: u64
L9:	loc7: u64
B0:
CopyLoc[0](Arg0: &Order)
Call order_id(&Order): u128
Call utils::decode_order_id(u128): bool * u64 * u64
Pop
StLoc[6](loc4: u64)
StLoc[4](loc2: bool)
LdU64(0)
StLoc[2](loc0: u64)
LdU64(0)
StLoc[7](loc5: u64)
CopyLoc[0](Arg0: &Order)
Call quantity(&Order): u64
CopyLoc[0](Arg0: &Order)
Call filled_quantity(&Order): u64
Sub
StLoc[8](loc6: u64)
CopyLoc[8](loc6: u64)
MoveLoc[6](loc4: u64)
Call math::mul(u64, u64): u64
StLoc[9](loc7: u64)
CopyLoc[4](loc2: bool)
BrFalse(27)
B1:
MoveLoc[7](loc5: u64)
CopyLoc[9](loc7: u64)
Add
StLoc[7](loc5: u64)
Branch(31)
B2:
MoveLoc[2](loc0: u64)
CopyLoc[8](loc6: u64)
Add
StLoc[2](loc0: u64)
B3:
MoveLoc[0](Arg0: &Order)
Call order_deep_price(&Order): &OrderDeepPrice
MoveLoc[8](loc6: u64)
MoveLoc[9](loc7: u64)
MoveLoc[4](loc2: bool)
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[3](loc1: Balances)
MutBorrowLoc[3](loc1: Balances)
MoveLoc[1](Arg1: u64)
Call balances::mul(&mut Balances, u64)
MoveLoc[2](loc0: u64)
MoveLoc[7](loc5: u64)
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[5](loc3: Balances)
MutBorrowLoc[5](loc3: Balances)
MoveLoc[3](loc1: Balances)
Call balances::add_balances(&mut Balances, Balances)
MoveLoc[5](loc3: Balances)
Ret
}
public(friend) emit_order_canceled(Arg0: &Order, Arg1: ID, Arg2: address, Arg3: u64) {
L4:	loc0: ID
L5:	loc1: u64
L6:	loc2: u128
L7:	loc3: ID
L8:	loc4: u64
L9:	loc5: bool
L10:	loc6: address
L11:	loc7: u64
L12:	loc8: u64
L13:	loc9: u64
L14:	loc10: bool
L15:	loc11: u64
L16:	loc12: u64
B0:
CopyLoc[0](Arg0: &Order)
Call is_bid(&Order): bool
StLoc[14](loc10: bool)
CopyLoc[0](Arg0: &Order)
Call price(&Order): u64
StLoc[15](loc11: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
CopyLoc[0](Arg0: &Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
Sub
StLoc[16](loc12: u64)
MoveLoc[1](Arg1: ID)
StLoc[4](loc0: ID)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
StLoc[6](loc2: u128)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[0](Order.balance_manager_id: ID)
ReadRef
StLoc[7](loc3: ID)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[2](Order.client_order_id: u64)
ReadRef
StLoc[8](loc4: u64)
MoveLoc[14](loc10: bool)
StLoc[9](loc5: bool)
MoveLoc[2](Arg2: address)
StLoc[10](loc6: address)
MoveLoc[0](Arg0: &Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
StLoc[11](loc7: u64)
MoveLoc[16](loc12: u64)
StLoc[12](loc8: u64)
MoveLoc[3](Arg3: u64)
StLoc[13](loc9: u64)
MoveLoc[15](loc11: u64)
StLoc[5](loc1: u64)
MoveLoc[7](loc3: ID)
MoveLoc[4](loc0: ID)
MoveLoc[6](loc2: u128)
MoveLoc[8](loc4: u64)
MoveLoc[10](loc6: address)
MoveLoc[5](loc1: u64)
MoveLoc[9](loc5: bool)
MoveLoc[11](loc7: u64)
MoveLoc[12](loc8: u64)
MoveLoc[13](loc9: u64)
Pack[1](OrderCanceled)
Call event::emit<OrderCanceled>(OrderCanceled)
Ret
}
public(friend) emit_order_modified(Arg0: &Order, Arg1: ID, Arg2: u64, Arg3: address, Arg4: u64) {
L5:	loc0: u128
L6:	loc1: u64
L7:	loc2: u64
L8:	loc3: ID
L9:	loc4: u64
L10:	loc5: ID
L11:	loc6: address
L12:	loc7: u64
L13:	loc8: bool
L14:	loc9: u64
L15:	loc10: u64
L16:	loc11: bool
L17:	loc12: u64
B0:
CopyLoc[0](Arg0: &Order)
Call is_bid(&Order): bool
StLoc[16](loc11: bool)
CopyLoc[0](Arg0: &Order)
Call price(&Order): u64
StLoc[17](loc12: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
StLoc[5](loc0: u128)
MoveLoc[1](Arg1: ID)
StLoc[8](loc3: ID)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[2](Order.client_order_id: u64)
ReadRef
StLoc[9](loc4: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[0](Order.balance_manager_id: ID)
ReadRef
StLoc[10](loc5: ID)
MoveLoc[3](Arg3: address)
StLoc[11](loc6: address)
MoveLoc[17](loc12: u64)
StLoc[12](loc7: u64)
MoveLoc[16](loc11: bool)
StLoc[13](loc8: bool)
MoveLoc[2](Arg2: u64)
StLoc[14](loc9: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
StLoc[15](loc10: u64)
MoveLoc[0](Arg0: &Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
StLoc[6](loc1: u64)
MoveLoc[4](Arg4: u64)
StLoc[7](loc2: u64)
MoveLoc[10](loc5: ID)
MoveLoc[8](loc3: ID)
MoveLoc[5](loc0: u128)
MoveLoc[9](loc4: u64)
MoveLoc[11](loc6: address)
MoveLoc[12](loc7: u64)
MoveLoc[13](loc8: bool)
MoveLoc[14](loc9: u64)
MoveLoc[15](loc10: u64)
MoveLoc[6](loc1: u64)
MoveLoc[7](loc2: u64)
Pack[2](OrderModified)
Call event::emit<OrderModified>(OrderModified)
Ret
}
public(friend) emit_cancel_maker(Arg0: ID, Arg1: ID, Arg2: u128, Arg3: u64, Arg4: address, Arg5: u64, Arg6: bool, Arg7: u64, Arg8: u64, Arg9: u64) {
B0:
MoveLoc[0](Arg0: ID)
MoveLoc[1](Arg1: ID)
MoveLoc[2](Arg2: u128)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: address)
MoveLoc[5](Arg5: u64)
MoveLoc[6](Arg6: bool)
MoveLoc[7](Arg7: u64)
MoveLoc[8](Arg8: u64)
MoveLoc[9](Arg9: u64)
Pack[1](OrderCanceled)
Call event::emit<OrderCanceled>(OrderCanceled)
Ret
}
public(friend) copy_order(Arg0: &Order): Order {
L1:	loc0: u128
L2:	loc1: u64
L3:	loc2: ID
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: bool
L8:	loc7: OrderDeepPrice
L9:	loc8: u64
L10:	loc9: u8
B0:
CopyLoc[0](Arg0: &Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
StLoc[1](loc0: u128)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[0](Order.balance_manager_id: ID)
ReadRef
StLoc[3](loc2: ID)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[2](Order.client_order_id: u64)
ReadRef
StLoc[4](loc3: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[3](Order.quantity: u64)
ReadRef
StLoc[5](loc4: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[4](Order.filled_quantity: u64)
ReadRef
StLoc[6](loc5: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[5](Order.fee_is_deep: bool)
ReadRef
StLoc[7](loc6: bool)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[6](Order.order_deep_price: OrderDeepPrice)
ReadRef
StLoc[8](loc7: OrderDeepPrice)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[7](Order.epoch: u64)
ReadRef
StLoc[9](loc8: u64)
CopyLoc[0](Arg0: &Order)
ImmBorrowField[8](Order.status: u8)
ReadRef
StLoc[10](loc9: u8)
MoveLoc[0](Arg0: &Order)
ImmBorrowField[9](Order.expire_timestamp: u64)
ReadRef
StLoc[2](loc1: u64)
MoveLoc[3](loc2: ID)
MoveLoc[1](loc0: u128)
MoveLoc[4](loc3: u64)
MoveLoc[5](loc4: u64)
MoveLoc[6](loc5: u64)
MoveLoc[7](loc6: bool)
MoveLoc[8](loc7: OrderDeepPrice)
MoveLoc[9](loc8: u64)
MoveLoc[10](loc9: u8)
MoveLoc[2](loc1: u64)
Pack[0](Order)
Ret
}
public(friend) set_canceled(Arg0: &mut Order) {
B0:
Call constants::canceled(): u8
MoveLoc[0](Arg0: &mut Order)
MutBorrowField[8](Order.status: u8)
WriteRef
Ret
}
public(friend) is_bid(Arg0: &Order): bool {
B0:
MoveLoc[0](Arg0: &Order)
ImmBorrowField[1](Order.order_id: u128)
ReadRef
Call utils::decode_order_id(u128): bool * u64 * u64
Pop
Pop
Ret
}
Constants [
=> u64: 0
=> u64: 1
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/order_info.mvb1399 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.order_info {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::deep_price;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::fill;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
struct OrderInfo has copy, drop, store {
	pool_id: ID,
	order_id: u128,
	balance_manager_id: ID,
	client_order_id: u64,
	trader: address,
	order_type: u8,
	self_matching_option: u8,
	price: u64,
	is_bid: bool,
	original_quantity: u64,
	order_deep_price: OrderDeepPrice,
	expire_timestamp: u64,
	executed_quantity: u64,
	cumulative_quote_quantity: u64,
	fills: vector<Fill>,
	fee_is_deep: bool,
	paid_fees: u64,
	maker_fees: u64,
	epoch: u64,
	status: u8,
	market_order: bool,
	fill_limit_reached: bool,
	order_inserted: bool,
	timestamp: u64
}
struct OrderFilled has copy, drop, store {
	pool_id: ID,
	maker_order_id: u128,
	taker_order_id: u128,
	maker_client_order_id: u64,
	taker_client_order_id: u64,
	price: u64,
	taker_is_bid: bool,
	taker_fee: u64,
	taker_fee_is_deep: bool,
	maker_fee: u64,
	maker_fee_is_deep: bool,
	base_quantity: u64,
	quote_quantity: u64,
	maker_balance_manager_id: ID,
	taker_balance_manager_id: ID,
	timestamp: u64
}
struct OrderPlaced has copy, drop, store {
	balance_manager_id: ID,
	pool_id: ID,
	order_id: u128,
	client_order_id: u64,
	trader: address,
	price: u64,
	is_bid: bool,
	placed_quantity: u64,
	expire_timestamp: u64,
	timestamp: u64
}
struct OrderExpired has copy, drop, store {
	balance_manager_id: ID,
	pool_id: ID,
	order_id: u128,
	client_order_id: u64,
	trader: address,
	price: u64,
	is_bid: bool,
	original_quantity: u64,
	base_asset_quantity_canceled: u64,
	timestamp: u64
}
public pool_id(Arg0: &OrderInfo): ID {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[0](OrderInfo.pool_id: ID)
ReadRef
Ret
}
public order_id(Arg0: &OrderInfo): u128 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[1](OrderInfo.order_id: u128)
ReadRef
Ret
}
public balance_manager_id(Arg0: &OrderInfo): ID {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[2](OrderInfo.balance_manager_id: ID)
ReadRef
Ret
}
public client_order_id(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[3](OrderInfo.client_order_id: u64)
ReadRef
Ret
}
public trader(Arg0: &OrderInfo): address {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[4](OrderInfo.trader: address)
ReadRef
Ret
}
public order_type(Arg0: &OrderInfo): u8 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Ret
}
public self_matching_option(Arg0: &OrderInfo): u8 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[6](OrderInfo.self_matching_option: u8)
ReadRef
Ret
}
public price(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
Ret
}
public is_bid(Arg0: &OrderInfo): bool {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
Ret
}
public original_quantity(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
Ret
}
public order_deep_price(Arg0: &OrderInfo): OrderDeepPrice {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[10](OrderInfo.order_deep_price: OrderDeepPrice)
ReadRef
Ret
}
public expire_timestamp(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[11](OrderInfo.expire_timestamp: u64)
ReadRef
Ret
}
public executed_quantity(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
Ret
}
public cumulative_quote_quantity(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[13](OrderInfo.cumulative_quote_quantity: u64)
ReadRef
Ret
}
public fills(Arg0: &OrderInfo): vector<Fill> {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[14](OrderInfo.fills: vector<Fill>)
ReadRef
Ret
}
public fee_is_deep(Arg0: &OrderInfo): bool {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[15](OrderInfo.fee_is_deep: bool)
ReadRef
Ret
}
public paid_fees(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[16](OrderInfo.paid_fees: u64)
ReadRef
Ret
}
public maker_fees(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[17](OrderInfo.maker_fees: u64)
ReadRef
Ret
}
public epoch(Arg0: &OrderInfo): u64 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[18](OrderInfo.epoch: u64)
ReadRef
Ret
}
public status(Arg0: &OrderInfo): u8 {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[19](OrderInfo.status: u8)
ReadRef
Ret
}
public fill_limit_reached(Arg0: &OrderInfo): bool {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[20](OrderInfo.fill_limit_reached: bool)
ReadRef
Ret
}
public order_inserted(Arg0: &OrderInfo): bool {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[21](OrderInfo.order_inserted: bool)
ReadRef
Ret
}
public(friend) new(Arg0: ID, Arg1: ID, Arg2: u64, Arg3: address, Arg4: u8, Arg5: u8, Arg6: u64, Arg7: u64, Arg8: bool, Arg9: bool, Arg10: u64, Arg11: u64, Arg12: OrderDeepPrice, Arg13: bool, Arg14: u64): OrderInfo {
L15:	loc0: ID
L16:	loc1: u64
L17:	loc2: OrderDeepPrice
L18:	loc3: u64
L19:	loc4: bool
L20:	loc5: u64
L21:	loc6: u8
L22:	loc7: bool
L23:	loc8: u64
L24:	loc9: ID
L25:	loc10: u64
L26:	loc11: address
L27:	loc12: u8
L28:	loc13: u8
L29:	loc14: u64
L30:	loc15: bool
B0:
MoveLoc[0](Arg0: ID)
StLoc[15](loc0: ID)
MoveLoc[1](Arg1: ID)
StLoc[24](loc9: ID)
MoveLoc[2](Arg2: u64)
StLoc[25](loc10: u64)
MoveLoc[3](Arg3: address)
StLoc[26](loc11: address)
MoveLoc[4](Arg4: u8)
StLoc[27](loc12: u8)
MoveLoc[5](Arg5: u8)
StLoc[28](loc13: u8)
MoveLoc[6](Arg6: u64)
StLoc[29](loc14: u64)
MoveLoc[8](Arg8: bool)
StLoc[30](loc15: bool)
MoveLoc[7](Arg7: u64)
StLoc[16](loc1: u64)
MoveLoc[12](Arg12: OrderDeepPrice)
StLoc[17](loc2: OrderDeepPrice)
MoveLoc[11](Arg11: u64)
StLoc[18](loc3: u64)
MoveLoc[9](Arg9: bool)
StLoc[19](loc4: bool)
MoveLoc[10](Arg10: u64)
StLoc[20](loc5: u64)
Call constants::live(): u8
StLoc[21](loc6: u8)
MoveLoc[13](Arg13: bool)
StLoc[22](loc7: bool)
MoveLoc[14](Arg14: u64)
StLoc[23](loc8: u64)
MoveLoc[15](loc0: ID)
LdU128(0)
MoveLoc[24](loc9: ID)
MoveLoc[25](loc10: u64)
MoveLoc[26](loc11: address)
MoveLoc[27](loc12: u8)
MoveLoc[28](loc13: u8)
MoveLoc[29](loc14: u64)
MoveLoc[30](loc15: bool)
MoveLoc[16](loc1: u64)
MoveLoc[17](loc2: OrderDeepPrice)
MoveLoc[18](loc3: u64)
LdU64(0)
LdU64(0)
VecPack(29, 0)
MoveLoc[19](loc4: bool)
LdU64(0)
LdU64(0)
MoveLoc[20](loc5: u64)
MoveLoc[21](loc6: u8)
MoveLoc[22](loc7: bool)
LdFalse
LdFalse
MoveLoc[23](loc8: u64)
Pack[0](OrderInfo)
Ret
}
public(friend) market_order(Arg0: &OrderInfo): bool {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[22](OrderInfo.market_order: bool)
ReadRef
Ret
}
public(friend) set_order_id(Arg0: &mut OrderInfo, Arg1: u128) {
B0:
MoveLoc[1](Arg1: u128)
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[1](OrderInfo.order_id: u128)
WriteRef
Ret
}
public(friend) set_paid_fees(Arg0: &mut OrderInfo, Arg1: u64) {
B0:
MoveLoc[1](Arg1: u64)
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[16](OrderInfo.paid_fees: u64)
WriteRef
Ret
}
public(friend) add_fill(Arg0: &mut OrderInfo, Arg1: Fill) {
B0:
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[14](OrderInfo.fills: vector<Fill>)
MoveLoc[1](Arg1: Fill)
VecPushBack(29)
Ret
}
public(friend) fills_ref(Arg0: &mut OrderInfo): &mut vector<Fill> {
B0:
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[14](OrderInfo.fills: vector<Fill>)
Ret
}
public(friend) paid_fees_balances(Arg0: &OrderInfo): Balances {
L1:	loc0: Balances
L2:	loc1: Balances
B0:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[15](OrderInfo.fee_is_deep: bool)
ReadRef
BrFalse(12)
B1:
LdU64(0)
LdU64(0)
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[16](OrderInfo.paid_fees: u64)
ReadRef
Call balances::new(u64, u64, u64): Balances
StLoc[2](loc1: Balances)
Branch(33)
B2:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
BrFalse(24)
B3:
LdU64(0)
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[16](OrderInfo.paid_fees: u64)
ReadRef
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[1](loc0: Balances)
Branch(31)
B4:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[16](OrderInfo.paid_fees: u64)
ReadRef
LdU64(0)
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[1](loc0: Balances)
B5:
MoveLoc[1](loc0: Balances)
StLoc[2](loc1: Balances)
B6:
MoveLoc[2](loc1: Balances)
Ret
}
public(friend) calculate_partial_fill_balances(Arg0: &mut OrderInfo, Arg1: u64, Arg2: u64): Balances * Balances {
L3:	loc0: u64
L4:	loc1: &mut Fill
L5:	loc2: Balances
L6:	loc3: &mut vector<Fill>
L7:	loc4: u64
L8:	loc5: Balances
L9:	loc6: u64
L10:	loc7: Balances
L11:	loc8: u64
L12:	loc9: u64
L13:	loc10: Balances
L14:	loc11: Balances
B0:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[10](OrderInfo.order_deep_price: OrderDeepPrice)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[13](OrderInfo.cumulative_quote_quantity: u64)
ReadRef
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[14](loc11: Balances)
MutBorrowLoc[14](loc11: Balances)
CopyLoc[1](Arg1: u64)
Call balances::mul(&mut Balances, u64)
ImmBorrowLoc[14](loc11: Balances)
Call balances::non_zero_value(&Balances): u64
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[16](OrderInfo.paid_fees: u64)
WriteRef
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[14](OrderInfo.fills: vector<Fill>)
StLoc[6](loc3: &mut vector<Fill>)
LdU64(0)
StLoc[7](loc4: u64)
CopyLoc[6](loc3: &mut vector<Fill>)
FreezeRef
VecLen(29)
StLoc[9](loc6: u64)
B1:
CopyLoc[7](loc4: u64)
CopyLoc[9](loc6: u64)
Lt
BrFalse(75)
B2:
Branch(35)
B3:
CopyLoc[6](loc3: &mut vector<Fill>)
CopyLoc[7](loc4: u64)
VecMutBorrow(29)
StLoc[4](loc1: &mut Fill)
CopyLoc[4](loc1: &mut Fill)
FreezeRef
Call fill::expired(&Fill): bool
Not
BrFalse(68)
B4:
CopyLoc[4](loc1: &mut Fill)
FreezeRef
Call fill::base_quantity(&Fill): u64
StLoc[3](loc0: u64)
CopyLoc[4](loc1: &mut Fill)
FreezeRef
Call fill::quote_quantity(&Fill): u64
StLoc[11](loc8: u64)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[10](OrderInfo.order_deep_price: OrderDeepPrice)
MoveLoc[3](loc0: u64)
MoveLoc[11](loc8: u64)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[5](loc2: Balances)
MutBorrowLoc[5](loc2: Balances)
CopyLoc[1](Arg1: u64)
Call balances::mul(&mut Balances, u64)
MoveLoc[4](loc1: &mut Fill)
ImmBorrowLoc[5](loc2: Balances)
Call fill::set_fill_taker_fee(&mut Fill, &Balances)
Branch(70)
B5:
MoveLoc[4](loc1: &mut Fill)
Pop
B6:
MoveLoc[7](loc4: u64)
LdU64(1)
Add
StLoc[7](loc4: u64)
Branch(30)
B7:
MoveLoc[6](loc3: &mut vector<Fill>)
Pop
LdU64(0)
LdU64(0)
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[13](loc10: Balances)
LdU64(0)
LdU64(0)
LdU64(0)
Call balances::new(u64, u64, u64): Balances
StLoc[10](loc7: Balances)
MutBorrowLoc[10](loc7: Balances)
MoveLoc[14](loc11: Balances)
Call balances::add_balances(&mut Balances, Balances)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
BrFalse(105)
B8:
MutBorrowLoc[13](loc10: Balances)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
Call balances::add_base(&mut Balances, u64)
MutBorrowLoc[10](loc7: Balances)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[13](OrderInfo.cumulative_quote_quantity: u64)
ReadRef
Call balances::add_quote(&mut Balances, u64)
Branch(115)
B9:
MutBorrowLoc[13](loc10: Balances)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[13](OrderInfo.cumulative_quote_quantity: u64)
ReadRef
Call balances::add_quote(&mut Balances, u64)
MutBorrowLoc[10](loc7: Balances)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
Call balances::add_base(&mut Balances, u64)
B10:
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call remaining_quantity(&OrderInfo): u64
StLoc[12](loc9: u64)
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call order_inserted(&OrderInfo): bool
BrFalse(165)
B11:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[10](OrderInfo.order_deep_price: OrderDeepPrice)
CopyLoc[12](loc9: u64)
CopyLoc[12](loc9: u64)
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call price(&OrderInfo): u64
Call math::mul(u64, u64): u64
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[8](loc5: Balances)
MutBorrowLoc[8](loc5: Balances)
MoveLoc[2](Arg2: u64)
Call balances::mul(&mut Balances, u64)
ImmBorrowLoc[8](loc5: Balances)
Call balances::non_zero_value(&Balances): u64
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[17](OrderInfo.maker_fees: u64)
WriteRef
MutBorrowLoc[10](loc7: Balances)
MoveLoc[8](loc5: Balances)
Call balances::add_balances(&mut Balances, Balances)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
BrFalse(159)
B12:
MutBorrowLoc[10](loc7: Balances)
MoveLoc[12](loc9: u64)
MoveLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call price(&OrderInfo): u64
Call math::mul(u64, u64): u64
Call balances::add_quote(&mut Balances, u64)
Branch(167)
B13:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
MutBorrowLoc[10](loc7: Balances)
MoveLoc[12](loc9: u64)
Call balances::add_base(&mut Balances, u64)
Branch(167)
B14:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
B15:
MoveLoc[13](loc10: Balances)
MoveLoc[10](loc7: Balances)
Ret
}
public(friend) to_order(Arg0: &OrderInfo): Order {
B0:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[1](OrderInfo.order_id: u128)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[2](OrderInfo.balance_manager_id: ID)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[3](OrderInfo.client_order_id: u64)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[15](OrderInfo.fee_is_deep: bool)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[10](OrderInfo.order_deep_price: OrderDeepPrice)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[18](OrderInfo.epoch: u64)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[19](OrderInfo.status: u8)
ReadRef
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[11](OrderInfo.expire_timestamp: u64)
ReadRef
Call order::new(u128, ID, u64, u64, u64, bool, OrderDeepPrice, u64, u8, u64): Order
Ret
}
public(friend) validate_inputs(Arg0: &OrderInfo, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: u64) {
L5:	loc0: bool
L6:	loc1: bool
B0:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
MoveLoc[2](Arg2: u64)
Ge
BrFalse(7)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdConst[1](u64: 1)
Abort
B3:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
MoveLoc[3](Arg3: u64)
Mod
LdU64(0)
Eq
BrFalse(20)
B4:
Branch(24)
B5:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdConst[2](u64: 2)
Abort
B6:
MoveLoc[4](Arg4: u64)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[11](OrderInfo.expire_timestamp: u64)
ReadRef
Le
BrFalse(31)
B7:
Branch(35)
B8:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdConst[3](u64: 3)
Abort
B9:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Call constants::no_restriction(): u8
Ge
BrFalse(48)
B10:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Call constants::max_restriction(): u8
Le
StLoc[5](loc0: bool)
Branch(50)
B11:
LdFalse
StLoc[5](loc0: bool)
B12:
MoveLoc[5](loc0: bool)
BrFalse(53)
B13:
Branch(57)
B14:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdConst[4](u64: 4)
Abort
B15:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[22](OrderInfo.market_order: bool)
ReadRef
BrFalse(71)
B16:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Call constants::post_only(): u8
Neq
BrFalse(68)
B17:
Branch(70)
B18:
LdConst[7](u64: 7)
Abort
B19:
Ret
B20:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
Call constants::min_price(): u64
Ge
BrFalse(84)
B21:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
Call constants::max_price(): u64
Le
StLoc[6](loc1: bool)
Branch(86)
B22:
LdFalse
StLoc[6](loc1: bool)
B23:
MoveLoc[6](loc1: bool)
BrFalse(89)
B24:
Branch(93)
B25:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdConst[0](u64: 0)
Abort
B26:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
MoveLoc[1](Arg1: u64)
Mod
LdU64(0)
Eq
BrFalse(102)
B27:
Branch(104)
B28:
LdConst[0](u64: 0)
Abort
B29:
Ret
}
public(friend) assert_execution(Arg0: &mut OrderInfo): bool {
B0:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Call constants::post_only(): u8
Eq
BrFalse(17)
B1:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
LdU64(0)
Eq
BrFalse(13)
B2:
Branch(17)
B3:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
LdConst[5](u64: 5)
Abort
B4:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Call constants::fill_or_kill(): u8
Eq
BrFalse(36)
B5:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
Eq
BrFalse(32)
B6:
Branch(36)
B7:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
LdConst[6](u64: 6)
Abort
B8:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[5](OrderInfo.order_type: u8)
ReadRef
Call constants::immediate_or_cancel(): u8
Eq
BrFalse(59)
B9:
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call remaining_quantity(&OrderInfo): u64
LdU64(0)
Gt
BrFalse(53)
B10:
Call constants::canceled(): u8
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[19](OrderInfo.status: u8)
WriteRef
Branch(57)
B11:
Call constants::filled(): u8
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[19](OrderInfo.status: u8)
WriteRef
B12:
LdTrue
Ret
B13:
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call remaining_quantity(&OrderInfo): u64
LdU64(0)
Eq
BrFalse(71)
B14:
Call constants::filled(): u8
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[19](OrderInfo.status: u8)
WriteRef
LdTrue
Ret
B15:
MoveLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[20](OrderInfo.fill_limit_reached: bool)
ReadRef
BrFalse(77)
B16:
LdTrue
Ret
B17:
LdFalse
Ret
}
public(friend) remaining_quantity(Arg0: &OrderInfo): u64 {
B0:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
Sub
Ret
}
public(friend) can_match(Arg0: &OrderInfo, Arg1: &Order): bool {
L2:	loc0: bool
L3:	loc1: bool
L4:	loc2: bool
L5:	loc3: bool
L6:	loc4: u64
B0:
MoveLoc[1](Arg1: &Order)
Call order::price(&Order): u64
StLoc[6](loc4: u64)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[9](OrderInfo.original_quantity: u64)
ReadRef
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
Sub
LdU64(0)
Gt
BrFalse(54)
B1:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
BrFalse(24)
B2:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
CopyLoc[6](loc4: u64)
Ge
StLoc[5](loc3: bool)
Branch(26)
B3:
LdFalse
StLoc[5](loc3: bool)
B4:
MoveLoc[5](loc3: bool)
BrFalse(33)
B5:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdTrue
StLoc[3](loc1: bool)
Branch(51)
B6:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
Not
BrFalse(45)
B7:
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
MoveLoc[6](loc4: u64)
Le
StLoc[4](loc2: bool)
Branch(49)
B8:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdFalse
StLoc[4](loc2: bool)
B9:
MoveLoc[4](loc2: bool)
StLoc[3](loc1: bool)
B10:
MoveLoc[3](loc1: bool)
StLoc[2](loc0: bool)
Branch(58)
B11:
MoveLoc[0](Arg0: &OrderInfo)
Pop
LdFalse
StLoc[2](loc0: bool)
B12:
MoveLoc[2](loc0: bool)
Ret
}
public(friend) match_maker(Arg0: &mut OrderInfo, Arg1: &mut Order, Arg2: u64): bool {
L3:	loc0: bool
L4:	loc1: bool
L5:	loc2: Fill
B0:
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
CopyLoc[1](Arg1: &mut Order)
FreezeRef
Call can_match(&OrderInfo, &Order): bool
Not
BrFalse(13)
B1:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
MoveLoc[1](Arg1: &mut Order)
Pop
LdFalse
Ret
B2:
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call self_matching_option(&OrderInfo): u8
Call constants::cancel_taker(): u8
Eq
BrFalse(34)
B3:
CopyLoc[1](Arg1: &mut Order)
FreezeRef
Call order::balance_manager_id(&Order): ID
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call balance_manager_id(&OrderInfo): ID
Neq
BrFalse(28)
B4:
Branch(34)
B5:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
MoveLoc[1](Arg1: &mut Order)
Pop
LdConst[8](u64: 8)
Abort
B6:
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call self_matching_option(&OrderInfo): u8
Call constants::cancel_maker(): u8
Eq
BrFalse(49)
B7:
CopyLoc[1](Arg1: &mut Order)
FreezeRef
Call order::balance_manager_id(&Order): ID
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call balance_manager_id(&OrderInfo): ID
Eq
StLoc[3](loc0: bool)
Branch(51)
B8:
LdFalse
StLoc[3](loc0: bool)
B9:
MoveLoc[3](loc0: bool)
StLoc[4](loc1: bool)
MoveLoc[1](Arg1: &mut Order)
MoveLoc[2](Arg2: u64)
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call remaining_quantity(&OrderInfo): u64
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
MoveLoc[4](loc1: bool)
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[15](OrderInfo.fee_is_deep: bool)
ReadRef
Call order::generate_fill(&mut Order, u64, u64, bool, bool, bool): Fill
StLoc[5](loc2: Fill)
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[14](OrderInfo.fills: vector<Fill>)
CopyLoc[5](loc2: Fill)
VecPushBack(29)
ImmBorrowLoc[5](loc2: Fill)
Call fill::expired(&Fill): bool
BrFalse(78)
B10:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
LdTrue
Ret
B11:
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[12](OrderInfo.executed_quantity: u64)
ReadRef
ImmBorrowLoc[5](loc2: Fill)
Call fill::base_quantity(&Fill): u64
Add
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[12](OrderInfo.executed_quantity: u64)
WriteRef
CopyLoc[0](Arg0: &mut OrderInfo)
ImmBorrowField[13](OrderInfo.cumulative_quote_quantity: u64)
ReadRef
ImmBorrowLoc[5](loc2: Fill)
Call fill::quote_quantity(&Fill): u64
Add
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[13](OrderInfo.cumulative_quote_quantity: u64)
WriteRef
Call constants::partially_filled(): u8
CopyLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[19](OrderInfo.status: u8)
WriteRef
CopyLoc[0](Arg0: &mut OrderInfo)
FreezeRef
Call remaining_quantity(&OrderInfo): u64
LdU64(0)
Eq
BrFalse(111)
B12:
Call constants::filled(): u8
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[19](OrderInfo.status: u8)
WriteRef
Branch(113)
B13:
MoveLoc[0](Arg0: &mut OrderInfo)
Pop
B14:
LdTrue
Ret
}
public(friend) emit_orders_filled(Arg0: &OrderInfo, Arg1: u64) {
L2:	loc0: &Fill
L3:	loc1: u64
L4:	loc2: u64
B0:
LdU64(0)
StLoc[3](loc1: u64)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[14](OrderInfo.fills: vector<Fill>)
VecLen(29)
StLoc[4](loc2: u64)
B1:
CopyLoc[3](loc1: u64)
CopyLoc[4](loc2: u64)
Lt
BrFalse(47)
B2:
Branch(11)
B3:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[14](OrderInfo.fills: vector<Fill>)
CopyLoc[3](loc1: u64)
VecImmBorrow(29)
StLoc[2](loc0: &Fill)
CopyLoc[2](loc0: &Fill)
Call fill::expired(&Fill): bool
Not
BrFalse(26)
B4:
CopyLoc[0](Arg0: &OrderInfo)
MoveLoc[2](loc0: &Fill)
CopyLoc[1](Arg1: u64)
Call order_filled_from_fill(&OrderInfo, &Fill, u64): OrderFilled
Call event::emit<OrderFilled>(OrderFilled)
Branch(42)
B5:
CopyLoc[0](Arg0: &OrderInfo)
Call balance_manager_id(&OrderInfo): ID
CopyLoc[2](loc0: &Fill)
Call fill::balance_manager_id(&Fill): ID
Eq
BrFalse(37)
B6:
CopyLoc[0](Arg0: &OrderInfo)
MoveLoc[2](loc0: &Fill)
CopyLoc[1](Arg1: u64)
Call emit_order_canceled_maker_from_fill(&OrderInfo, &Fill, u64)
Branch(42)
B7:
CopyLoc[0](Arg0: &OrderInfo)
MoveLoc[2](loc0: &Fill)
CopyLoc[1](Arg1: u64)
Call order_expired_from_fill(&OrderInfo, &Fill, u64): OrderExpired
Call event::emit<OrderExpired>(OrderExpired)
B8:
MoveLoc[3](loc1: u64)
LdU64(1)
Add
StLoc[3](loc1: u64)
Branch(6)
B9:
MoveLoc[0](Arg0: &OrderInfo)
Pop
Ret
}
public(friend) emit_order_placed(Arg0: &OrderInfo) {
L1:	loc0: ID
L2:	loc1: u64
L3:	loc2: ID
L4:	loc3: u128
L5:	loc4: u64
L6:	loc5: bool
L7:	loc6: address
L8:	loc7: u64
L9:	loc8: u64
L10:	loc9: u64
B0:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[2](OrderInfo.balance_manager_id: ID)
ReadRef
StLoc[1](loc0: ID)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[0](OrderInfo.pool_id: ID)
ReadRef
StLoc[3](loc2: ID)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[1](OrderInfo.order_id: u128)
ReadRef
StLoc[4](loc3: u128)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[3](OrderInfo.client_order_id: u64)
ReadRef
StLoc[5](loc4: u64)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
StLoc[6](loc5: bool)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[4](OrderInfo.trader: address)
ReadRef
StLoc[7](loc6: address)
CopyLoc[0](Arg0: &OrderInfo)
Call remaining_quantity(&OrderInfo): u64
StLoc[8](loc7: u64)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[7](OrderInfo.price: u64)
ReadRef
StLoc[9](loc8: u64)
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[11](OrderInfo.expire_timestamp: u64)
ReadRef
StLoc[10](loc9: u64)
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[23](OrderInfo.timestamp: u64)
ReadRef
StLoc[2](loc1: u64)
MoveLoc[1](loc0: ID)
MoveLoc[3](loc2: ID)
MoveLoc[4](loc3: u128)
MoveLoc[5](loc4: u64)
MoveLoc[7](loc6: address)
MoveLoc[9](loc8: u64)
MoveLoc[6](loc5: bool)
MoveLoc[8](loc7: u64)
MoveLoc[10](loc9: u64)
MoveLoc[2](loc1: u64)
Pack[2](OrderPlaced)
Call event::emit<OrderPlaced>(OrderPlaced)
Ret
}
public(friend) emit_order_info(Arg0: &OrderInfo) {
B0:
MoveLoc[0](Arg0: &OrderInfo)
ReadRef
Call event::emit<OrderInfo>(OrderInfo)
Ret
}
public(friend) set_fill_limit_reached(Arg0: &mut OrderInfo) {
B0:
LdTrue
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[20](OrderInfo.fill_limit_reached: bool)
WriteRef
Ret
}
public(friend) set_order_inserted(Arg0: &mut OrderInfo) {
B0:
LdTrue
MoveLoc[0](Arg0: &mut OrderInfo)
MutBorrowField[21](OrderInfo.order_inserted: bool)
WriteRef
Ret
}
order_filled_from_fill(Arg0: &OrderInfo, Arg1: &Fill, Arg2: u64): OrderFilled {
B0:
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[0](OrderInfo.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::maker_order_id(&Fill): u128
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[1](OrderInfo.order_id: u128)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::maker_client_order_id(&Fill): u64
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[3](OrderInfo.client_order_id: u64)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::execution_price(&Fill): u64
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[8](OrderInfo.is_bid: bool)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::taker_fee(&Fill): u64
CopyLoc[1](Arg1: &Fill)
Call fill::taker_fee_is_deep(&Fill): bool
CopyLoc[1](Arg1: &Fill)
Call fill::maker_fee(&Fill): u64
CopyLoc[1](Arg1: &Fill)
Call fill::maker_fee_is_deep(&Fill): bool
CopyLoc[1](Arg1: &Fill)
Call fill::base_quantity(&Fill): u64
CopyLoc[1](Arg1: &Fill)
Call fill::quote_quantity(&Fill): u64
MoveLoc[1](Arg1: &Fill)
Call fill::balance_manager_id(&Fill): ID
MoveLoc[0](Arg0: &OrderInfo)
ImmBorrowField[2](OrderInfo.balance_manager_id: ID)
ReadRef
MoveLoc[2](Arg2: u64)
Pack[1](OrderFilled)
Ret
}
order_expired_from_fill(Arg0: &OrderInfo, Arg1: &Fill, Arg2: u64): OrderExpired {
B0:
CopyLoc[1](Arg1: &Fill)
Call fill::balance_manager_id(&Fill): ID
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[0](OrderInfo.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::maker_order_id(&Fill): u128
CopyLoc[1](Arg1: &Fill)
Call fill::maker_client_order_id(&Fill): u64
CopyLoc[0](Arg0: &OrderInfo)
Call trader(&OrderInfo): address
CopyLoc[1](Arg1: &Fill)
Call fill::execution_price(&Fill): u64
MoveLoc[0](Arg0: &OrderInfo)
Call is_bid(&OrderInfo): bool
Not
CopyLoc[1](Arg1: &Fill)
Call fill::original_maker_quantity(&Fill): u64
MoveLoc[1](Arg1: &Fill)
Call fill::base_quantity(&Fill): u64
MoveLoc[2](Arg2: u64)
Pack[3](OrderExpired)
Ret
}
emit_order_canceled_maker_from_fill(Arg0: &OrderInfo, Arg1: &Fill, Arg2: u64) {
B0:
CopyLoc[1](Arg1: &Fill)
Call fill::balance_manager_id(&Fill): ID
CopyLoc[0](Arg0: &OrderInfo)
ImmBorrowField[0](OrderInfo.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &Fill)
Call fill::maker_order_id(&Fill): u128
CopyLoc[1](Arg1: &Fill)
Call fill::maker_client_order_id(&Fill): u64
CopyLoc[0](Arg0: &OrderInfo)
Call trader(&OrderInfo): address
CopyLoc[1](Arg1: &Fill)
Call fill::execution_price(&Fill): u64
MoveLoc[0](Arg0: &OrderInfo)
Call is_bid(&OrderInfo): bool
Not
CopyLoc[1](Arg1: &Fill)
Call fill::original_maker_quantity(&Fill): u64
MoveLoc[1](Arg1: &Fill)
Call fill::base_quantity(&Fill): u64
MoveLoc[2](Arg2: u64)
Call order::emit_cancel_maker(ID, ID, u128, u64, address, u64, bool, u64, u64, u64)
Ret
}
Constants [
=> u64: 0
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 6
=> u64: 7
=> u64: 8
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/pool.mvb2476 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.pool {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::account;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balance_manager;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::big_vector;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::book;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::deep_price;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::governance;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::history;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order_info;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::registry;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::state;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::trade_params;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::vault;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000002::versioned;
use deeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep;
struct Pool<phantom Ty0, phantom Ty1> has key {
	id: UID,
	inner: Versioned
}
struct PoolInner<phantom Ty0, phantom Ty1> has store {
	allowed_versions: VecSet<u64>,
	pool_id: ID,
	book: Book,
	state: State,
	vault: Vault<Ty0, Ty1>,
	deep_price: DeepPrice,
	registered_pool: bool
}
struct PoolCreated<phantom Ty0, phantom Ty1> has copy, drop, store {
	pool_id: ID,
	taker_fee: u64,
	maker_fee: u64,
	tick_size: u64,
	lot_size: u64,
	min_size: u64,
	whitelisted_pool: bool,
	treasury_address: address
}
struct BookParamsUpdated<phantom Ty0, phantom Ty1> has copy, drop, store {
	pool_id: ID,
	tick_size: u64,
	lot_size: u64,
	min_size: u64,
	timestamp: u64
}
struct DeepBurned<phantom Ty0, phantom Ty1> has copy, drop, store {
	pool_id: ID,
	deep_burned: u64
}
public create_permissionless_pool<Ty0, Ty1>(Arg0: &mut Registry, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: Coin<DEEP>, Arg5: &mut TxContext): ID {
L6:	loc0: bool
L7:	loc1: TypeName
L8:	loc2: TypeName
L9:	loc3: bool
B0:
ImmBorrowLoc[4](Arg4: Coin<DEEP>)
Call coin::value<DEEP>(&Coin<DEEP>): u64
Call constants::pool_creation_fee(): u64
Eq
BrFalse(6)
B1:
Branch(12)
B2:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[5](Arg5: &mut TxContext)
Pop
LdConst[0](u64: 1)
Abort
B3:
Call type_name::get<Ty0>(): TypeName
StLoc[7](loc1: TypeName)
Call type_name::get<Ty1>(): TypeName
StLoc[8](loc2: TypeName)
CopyLoc[0](Arg0: &mut Registry)
FreezeRef
MoveLoc[7](loc1: TypeName)
Call registry::is_stablecoin(&Registry, TypeName): bool
BrFalse(27)
B4:
CopyLoc[0](Arg0: &mut Registry)
FreezeRef
MoveLoc[8](loc2: TypeName)
Call registry::is_stablecoin(&Registry, TypeName): bool
StLoc[6](loc0: bool)
Branch(29)
B5:
LdFalse
StLoc[6](loc0: bool)
B6:
MoveLoc[6](loc0: bool)
StLoc[9](loc3: bool)
MoveLoc[0](Arg0: &mut Registry)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: Coin<DEEP>)
LdFalse
MoveLoc[9](loc3: bool)
MoveLoc[5](Arg5: &mut TxContext)
Call create_pool<Ty0, Ty1>(&mut Registry, u64, u64, u64, Coin<DEEP>, bool, bool, &mut TxContext): ID
Ret
}
public place_limit_order<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u64, Arg4: u8, Arg5: u8, Arg6: u64, Arg7: u64, Arg8: bool, Arg9: bool, Arg10: u64, Arg11: &Clock, Arg12: &TxContext): OrderInfo {
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u8)
MoveLoc[5](Arg5: u8)
MoveLoc[6](Arg6: u64)
MoveLoc[7](Arg7: u64)
MoveLoc[8](Arg8: bool)
MoveLoc[9](Arg9: bool)
MoveLoc[10](Arg10: u64)
MoveLoc[11](Arg11: &Clock)
LdFalse
MoveLoc[12](Arg12: &TxContext)
Call place_order_int<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut BalanceManager, &TradeProof, u64, u8, u8, u64, u64, bool, bool, u64, &Clock, bool, &TxContext): OrderInfo
Ret
}
public place_market_order<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u64, Arg4: u8, Arg5: u64, Arg6: bool, Arg7: bool, Arg8: &Clock, Arg9: &TxContext): OrderInfo {
L10:	loc0: u64
L11:	loc1: u8
L12:	loc2: u8
L13:	loc3: u64
L14:	loc4: &TradeProof
L15:	loc5: &mut BalanceManager
L16:	loc6: &mut Pool<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
StLoc[16](loc6: &mut Pool<Ty0, Ty1>)
MoveLoc[1](Arg1: &mut BalanceManager)
StLoc[15](loc5: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
StLoc[14](loc4: &TradeProof)
MoveLoc[3](Arg3: u64)
StLoc[13](loc3: u64)
Call constants::immediate_or_cancel(): u8
StLoc[12](loc2: u8)
MoveLoc[4](Arg4: u8)
StLoc[11](loc1: u8)
CopyLoc[6](Arg6: bool)
BrFalse(17)
B1:
Call constants::max_price(): u64
StLoc[10](loc0: u64)
Branch(19)
B2:
Call constants::min_price(): u64
StLoc[10](loc0: u64)
B3:
MoveLoc[16](loc6: &mut Pool<Ty0, Ty1>)
MoveLoc[15](loc5: &mut BalanceManager)
MoveLoc[14](loc4: &TradeProof)
MoveLoc[13](loc3: u64)
MoveLoc[12](loc2: u8)
MoveLoc[11](loc1: u8)
MoveLoc[10](loc0: u64)
MoveLoc[5](Arg5: u64)
MoveLoc[6](Arg6: bool)
MoveLoc[7](Arg7: bool)
CopyLoc[8](Arg8: &Clock)
Call clock::timestamp_ms(&Clock): u64
MoveLoc[8](Arg8: &Clock)
LdTrue
MoveLoc[9](Arg9: &TxContext)
Call place_order_int<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut BalanceManager, &TradeProof, u64, u8, u8, u64, u64, bool, bool, u64, &Clock, bool, &TxContext): OrderInfo
Ret
}
public swap_exact_base_for_quote<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty0>, Arg2: Coin<DEEP>, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext): Coin<Ty0> * Coin<Ty1> * Coin<DEEP> {
L6:	loc0: Coin<Ty1>
B0:
CopyLoc[5](Arg5: &mut TxContext)
Call coin::zero<Ty1>(&mut TxContext): Coin<Ty1>
StLoc[6](loc0: Coin<Ty1>)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
MoveLoc[1](Arg1: Coin<Ty0>)
MoveLoc[6](loc0: Coin<Ty1>)
MoveLoc[2](Arg2: Coin<DEEP>)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: &Clock)
MoveLoc[5](Arg5: &mut TxContext)
Call swap_exact_quantity<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, Coin<DEEP>, u64, &Clock, &mut TxContext): Coin<Ty0> * Coin<Ty1> * Coin<DEEP>
Ret
}
public swap_exact_quote_for_base<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty1>, Arg2: Coin<DEEP>, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext): Coin<Ty0> * Coin<Ty1> * Coin<DEEP> {
L6:	loc0: Coin<Ty0>
B0:
CopyLoc[5](Arg5: &mut TxContext)
Call coin::zero<Ty0>(&mut TxContext): Coin<Ty0>
StLoc[6](loc0: Coin<Ty0>)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
MoveLoc[6](loc0: Coin<Ty0>)
MoveLoc[1](Arg1: Coin<Ty1>)
MoveLoc[2](Arg2: Coin<DEEP>)
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: &Clock)
MoveLoc[5](Arg5: &mut TxContext)
Call swap_exact_quantity<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Coin<Ty0>, Coin<Ty1>, Coin<DEEP>, u64, &Clock, &mut TxContext): Coin<Ty0> * Coin<Ty1> * Coin<DEEP>
Ret
}
public swap_exact_quantity<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty0>, Arg2: Coin<Ty1>, Arg3: Coin<DEEP>, Arg4: u64, Arg5: &Clock, Arg6: &mut TxContext): Coin<Ty0> * Coin<Ty1> * Coin<DEEP> {
L7:	loc0: TradeParams
L8:	loc1: u64
L9:	loc2: u64
L10:	loc3: u64
L11:	loc4: Coin<Ty0>
L12:	loc5: u64
L13:	loc6: Coin<DEEP>
L14:	loc7: u64
L15:	loc8: bool
L16:	loc9: bool
L17:	loc10: Coin<Ty1>
L18:	loc11: u64
L19:	loc12: BalanceManager
L20:	loc13: TradeProof
B0:
ImmBorrowLoc[1](Arg1: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
StLoc[12](loc5: u64)
ImmBorrowLoc[2](Arg2: Coin<Ty1>)
Call coin::value<Ty1>(&Coin<Ty1>): u64
StLoc[18](loc11: u64)
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[7](loc0: TradeParams)
ImmBorrowLoc[7](loc0: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
Call constants::fee_penalty_multiplier(): u64
Call math::mul(u64, u64): u64
StLoc[14](loc7: u64)
CopyLoc[12](loc5: u64)
LdU64(0)
Gt
CopyLoc[18](loc11: u64)
LdU64(0)
Gt
Neq
BrFalse(27)
B1:
Branch(35)
B2:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Pop
MoveLoc[6](Arg6: &mut TxContext)
Pop
MoveLoc[5](Arg5: &Clock)
Pop
LdConst[5](u64: 6)
Abort
B3:
ImmBorrowLoc[3](Arg3: Coin<DEEP>)
Call coin::value<DEEP>(&Coin<DEEP>): u64
LdU64(0)
Gt
StLoc[16](loc9: bool)
CopyLoc[18](loc11: u64)
LdU64(0)
Gt
StLoc[15](loc8: bool)
CopyLoc[15](loc8: bool)
BrFalse(74)
B4:
CopyLoc[16](loc9: bool)
BrFalse(58)
B5:
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
LdU64(0)
MoveLoc[18](loc11: u64)
CopyLoc[5](Arg5: &Clock)
Call get_quantity_out<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64, u64, &Clock): u64 * u64 * u64
StLoc[10](loc3: u64)
StLoc[9](loc2: u64)
StLoc[8](loc1: u64)
Branch(67)
B6:
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
LdU64(0)
MoveLoc[18](loc11: u64)
CopyLoc[5](Arg5: &Clock)
Call get_quantity_out_input_fee<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64, u64, &Clock): u64 * u64 * u64
StLoc[10](loc3: u64)
StLoc[9](loc2: u64)
StLoc[8](loc1: u64)
B7:
MoveLoc[8](loc1: u64)
MoveLoc[9](loc2: u64)
MoveLoc[10](loc3: u64)
Pop
Pop
StLoc[12](loc5: u64)
Branch(83)
B8:
CopyLoc[16](loc9: bool)
Not
BrFalse(83)
B9:
MoveLoc[12](loc5: u64)
Call constants::float_scaling(): u64
MoveLoc[14](loc7: u64)
Add
Call math::div(u64, u64): u64
StLoc[12](loc5: u64)
B10:
CopyLoc[12](loc5: u64)
MoveLoc[12](loc5: u64)
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
Mod
Sub
StLoc[12](loc5: u64)
CopyLoc[12](loc5: u64)
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::min_size(&Book): u64
Lt
BrFalse(111)
B11:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Pop
MoveLoc[6](Arg6: &mut TxContext)
Pop
MoveLoc[5](Arg5: &Clock)
Pop
MoveLoc[1](Arg1: Coin<Ty0>)
MoveLoc[2](Arg2: Coin<Ty1>)
MoveLoc[3](Arg3: Coin<DEEP>)
Ret
B12:
CopyLoc[6](Arg6: &mut TxContext)
Call balance_manager::new(&mut TxContext): BalanceManager
StLoc[19](loc12: BalanceManager)
MutBorrowLoc[19](loc12: BalanceManager)
CopyLoc[6](Arg6: &mut TxContext)
FreezeRef
Call balance_manager::generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
StLoc[20](loc13: TradeProof)
MutBorrowLoc[19](loc12: BalanceManager)
MoveLoc[1](Arg1: Coin<Ty0>)
CopyLoc[6](Arg6: &mut TxContext)
Call balance_manager::deposit<Ty0>(&mut BalanceManager, Coin<Ty0>, &mut TxContext)
MutBorrowLoc[19](loc12: BalanceManager)
MoveLoc[2](Arg2: Coin<Ty1>)
CopyLoc[6](Arg6: &mut TxContext)
Call balance_manager::deposit<Ty1>(&mut BalanceManager, Coin<Ty1>, &mut TxContext)
MutBorrowLoc[19](loc12: BalanceManager)
MoveLoc[3](Arg3: Coin<DEEP>)
CopyLoc[6](Arg6: &mut TxContext)
Call balance_manager::deposit<DEEP>(&mut BalanceManager, Coin<DEEP>, &mut TxContext)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
MutBorrowLoc[19](loc12: BalanceManager)
ImmBorrowLoc[20](loc13: TradeProof)
LdU64(0)
Call constants::self_matching_allowed(): u8
MoveLoc[12](loc5: u64)
CopyLoc[15](loc8: bool)
MoveLoc[16](loc9: bool)
MoveLoc[5](Arg5: &Clock)
CopyLoc[6](Arg6: &mut TxContext)
FreezeRef
Call place_market_order<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut BalanceManager, &TradeProof, u64, u8, u64, bool, bool, &Clock, &TxContext): OrderInfo
Pop
MutBorrowLoc[19](loc12: BalanceManager)
CopyLoc[6](Arg6: &mut TxContext)
Call balance_manager::withdraw_all<Ty0>(&mut BalanceManager, &mut TxContext): Coin<Ty0>
StLoc[11](loc4: Coin<Ty0>)
MutBorrowLoc[19](loc12: BalanceManager)
CopyLoc[6](Arg6: &mut TxContext)
Call balance_manager::withdraw_all<Ty1>(&mut BalanceManager, &mut TxContext): Coin<Ty1>
StLoc[17](loc10: Coin<Ty1>)
MutBorrowLoc[19](loc12: BalanceManager)
MoveLoc[6](Arg6: &mut TxContext)
Call balance_manager::withdraw_all<DEEP>(&mut BalanceManager, &mut TxContext): Coin<DEEP>
StLoc[13](loc6: Coin<DEEP>)
MoveLoc[15](loc8: bool)
BrFalse(166)
B13:
ImmBorrowLoc[11](loc4: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
MoveLoc[4](Arg4: u64)
Ge
BrFalse(164)
B14:
Branch(174)
B15:
LdConst[10](u64: 12)
Abort
B16:
ImmBorrowLoc[17](loc10: Coin<Ty1>)
Call coin::value<Ty1>(&Coin<Ty1>): u64
MoveLoc[4](Arg4: u64)
Ge
BrFalse(172)
B17:
Branch(174)
B18:
LdConst[10](u64: 12)
Abort
B19:
MoveLoc[19](loc12: BalanceManager)
Call balance_manager::delete(BalanceManager)
MoveLoc[11](loc4: Coin<Ty0>)
MoveLoc[17](loc10: Coin<Ty1>)
MoveLoc[13](loc6: Coin<DEEP>)
Ret
}
public modify_order<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u128, Arg4: u64, Arg5: &Clock, Arg6: &TxContext) {
L7:	loc0: Order
L8:	loc1: u64
L9:	loc2: &Order
L10:	loc3: Balances
L11:	loc4: u64
L12:	loc5: &mut PoolInner<Ty0, Ty1>
L13:	loc6: Balances
B0:
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
CopyLoc[3](Arg3: u128)
Call get_order<Ty0, Ty1>(&Pool<Ty0, Ty1>, u128): Order
StLoc[7](loc0: Order)
ImmBorrowLoc[7](loc0: Order)
Call order::quantity(&Order): u64
StLoc[11](loc4: u64)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
CopyLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[3](Arg3: u128)
MoveLoc[4](Arg4: u64)
CopyLoc[5](Arg5: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::modify_order(&mut Book, u128, u64, u64): u64 * &Order
StLoc[9](loc2: &Order)
StLoc[8](loc1: u64)
CopyLoc[9](loc2: &Order)
Call order::balance_manager_id(&Order): ID
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
Eq
BrFalse(28)
B1:
Branch(42)
B2:
MoveLoc[2](Arg2: &TradeProof)
Pop
MoveLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[9](loc2: &Order)
Pop
MoveLoc[6](Arg6: &TxContext)
Pop
MoveLoc[5](Arg5: &Clock)
Pop
MoveLoc[1](Arg1: &mut BalanceManager)
Pop
LdConst[7](u64: 9)
Abort
B3:
CopyLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
MoveLoc[8](loc1: u64)
CopyLoc[9](loc2: &Order)
CopyLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[6](Arg6: &TxContext)
Call state::process_modify(&mut State, ID, u64, &Order, ID, &TxContext): Balances * Balances
StLoc[10](loc3: Balances)
StLoc[13](loc6: Balances)
CopyLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[13](loc6: Balances)
MoveLoc[10](loc3: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
MoveLoc[9](loc2: &Order)
MoveLoc[12](loc5: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[11](loc4: u64)
MoveLoc[6](Arg6: &TxContext)
Call tx_context::sender(&TxContext): address
MoveLoc[5](Arg5: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call order::emit_order_modified(&Order, ID, u64, address, u64)
Ret
}
public cancel_order<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u128, Arg4: &Clock, Arg5: &TxContext) {
L6:	loc0: Order
L7:	loc1: Balances
L8:	loc2: &mut PoolInner<Ty0, Ty1>
L9:	loc3: Balances
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
CopyLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[3](Arg3: u128)
Call book::cancel_order(&mut Book, u128): Order
StLoc[6](loc0: Order)
ImmBorrowLoc[6](loc0: Order)
Call order::balance_manager_id(&Order): ID
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
Eq
BrFalse(16)
B1:
Branch(28)
B2:
MoveLoc[2](Arg2: &TradeProof)
Pop
MoveLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[5](Arg5: &TxContext)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
MoveLoc[1](Arg1: &mut BalanceManager)
Pop
LdConst[7](u64: 9)
Abort
B3:
CopyLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
MutBorrowLoc[6](loc0: Order)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
CopyLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[5](Arg5: &TxContext)
Call state::process_cancel(&mut State, &mut Order, ID, ID, &TxContext): Balances * Balances
StLoc[7](loc1: Balances)
StLoc[9](loc3: Balances)
CopyLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[9](loc3: Balances)
MoveLoc[7](loc1: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
ImmBorrowLoc[6](loc0: Order)
MoveLoc[8](loc2: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[5](Arg5: &TxContext)
Call tx_context::sender(&TxContext): address
MoveLoc[4](Arg4: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call order::emit_order_canceled(&Order, ID, address, u64)
Ret
}
public cancel_orders<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: vector<u128>, Arg4: &Clock, Arg5: &TxContext) {
L6:	loc0: u64
L7:	loc1: u64
L8:	loc2: u128
B0:
LdU64(0)
StLoc[6](loc0: u64)
ImmBorrowLoc[3](Arg3: vector<u128>)
VecLen(100)
StLoc[7](loc1: u64)
B1:
CopyLoc[6](loc0: u64)
CopyLoc[7](loc1: u64)
Lt
BrFalse(27)
B2:
Branch(10)
B3:
ImmBorrowLoc[3](Arg3: vector<u128>)
CopyLoc[6](loc0: u64)
VecImmBorrow(100)
ReadRef
StLoc[8](loc2: u128)
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
CopyLoc[1](Arg1: &mut BalanceManager)
CopyLoc[2](Arg2: &TradeProof)
MoveLoc[8](loc2: u128)
CopyLoc[4](Arg4: &Clock)
CopyLoc[5](Arg5: &TxContext)
Call cancel_order<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut BalanceManager, &TradeProof, u128, &Clock, &TxContext)
MoveLoc[6](loc0: u64)
LdU64(1)
Add
StLoc[6](loc0: u64)
Branch(5)
B4:
MoveLoc[2](Arg2: &TradeProof)
Pop
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Pop
MoveLoc[5](Arg5: &TxContext)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
MoveLoc[1](Arg1: &mut BalanceManager)
Pop
Ret
}
public cancel_all_orders<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: &Clock, Arg4: &TxContext) {
L5:	loc0: u64
L6:	loc1: &mut PoolInner<Ty0, Ty1>
L7:	loc2: u64
L8:	loc3: vector<u128>
L9:	loc4: u128
B0:
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
LdConst[14](vector<u128>: 00)
StLoc[8](loc3: vector<u128>)
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
Call state::account_exists(&State, ID): bool
BrFalse(22)
B1:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
Call state::account(&State, ID): &Account
Call account::open_orders(&Account): VecSet<u128>
Call vec_set::into_keys<u128>(VecSet<u128>): vector<u128>
StLoc[8](loc3: vector<u128>)
Branch(24)
B2:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
B3:
LdU64(0)
StLoc[5](loc0: u64)
ImmBorrowLoc[8](loc3: vector<u128>)
VecLen(100)
StLoc[7](loc2: u64)
B4:
CopyLoc[5](loc0: u64)
CopyLoc[7](loc2: u64)
Lt
BrFalse(51)
B5:
Branch(34)
B6:
ImmBorrowLoc[8](loc3: vector<u128>)
CopyLoc[5](loc0: u64)
VecImmBorrow(100)
ReadRef
StLoc[9](loc4: u128)
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
CopyLoc[1](Arg1: &mut BalanceManager)
CopyLoc[2](Arg2: &TradeProof)
MoveLoc[9](loc4: u128)
CopyLoc[3](Arg3: &Clock)
CopyLoc[4](Arg4: &TxContext)
Call cancel_order<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &mut BalanceManager, &TradeProof, u128, &Clock, &TxContext)
MoveLoc[5](loc0: u64)
LdU64(1)
Add
StLoc[5](loc0: u64)
Branch(29)
B7:
MoveLoc[2](Arg2: &TradeProof)
Pop
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &TxContext)
Pop
MoveLoc[3](Arg3: &Clock)
Pop
MoveLoc[1](Arg1: &mut BalanceManager)
Pop
Ret
}
public withdraw_settled_amounts<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof) {
L3:	loc0: Balances
L4:	loc1: &mut PoolInner<Ty0, Ty1>
L5:	loc2: Balances
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[4](loc1: &mut PoolInner<Ty0, Ty1>)
CopyLoc[4](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
Call state::withdraw_settled_amounts(&mut State, ID): Balances * Balances
StLoc[3](loc0: Balances)
StLoc[5](loc2: Balances)
MoveLoc[4](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[5](loc2: Balances)
MoveLoc[3](loc0: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
Ret
}
public stake<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u64, Arg4: &TxContext) {
L5:	loc0: Balances
L6:	loc1: &mut PoolInner<Ty0, Ty1>
L7:	loc2: Balances
B0:
CopyLoc[3](Arg3: u64)
LdU64(0)
Gt
BrFalse(5)
B1:
Branch(15)
B2:
MoveLoc[2](Arg2: &TradeProof)
Pop
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &TxContext)
Pop
MoveLoc[1](Arg1: &mut BalanceManager)
Pop
LdConst[11](u64: 13)
Abort
B3:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: &TxContext)
Call state::process_stake(&mut State, ID, ID, u64, &TxContext): Balances * Balances
StLoc[5](loc0: Balances)
StLoc[7](loc2: Balances)
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[7](loc2: Balances)
MoveLoc[5](loc0: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
Ret
}
public unstake<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: &TxContext) {
L4:	loc0: Balances
L5:	loc1: &mut PoolInner<Ty0, Ty1>
L6:	loc2: Balances
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
CopyLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
MoveLoc[3](Arg3: &TxContext)
Call state::process_unstake(&mut State, ID, ID, &TxContext): Balances * Balances
StLoc[4](loc0: Balances)
StLoc[6](loc2: Balances)
MoveLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[6](loc2: Balances)
MoveLoc[4](loc0: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
Ret
}
public submit_proposal<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &TxContext) {
L7:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[7](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
MoveLoc[2](Arg2: &TradeProof)
Call balance_manager::validate_proof(&BalanceManager, &TradeProof)
CopyLoc[7](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
MoveLoc[7](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u64)
MoveLoc[5](Arg5: u64)
MoveLoc[6](Arg6: &TxContext)
Call state::process_proposal(&mut State, ID, ID, u64, u64, u64, &TxContext)
Ret
}
public vote<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: ID, Arg4: &TxContext) {
L5:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[5](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
MoveLoc[2](Arg2: &TradeProof)
Call balance_manager::validate_proof(&BalanceManager, &TradeProof)
CopyLoc[5](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
MoveLoc[5](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
MoveLoc[3](Arg3: ID)
MoveLoc[4](Arg4: &TxContext)
Call state::process_vote(&mut State, ID, ID, ID, &TxContext)
Ret
}
public claim_rebates<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: &TxContext) {
L4:	loc0: Balances
L5:	loc1: &mut PoolInner<Ty0, Ty1>
L6:	loc2: Balances
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
CopyLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
MoveLoc[3](Arg3: &TxContext)
Call state::process_claim_rebates<Ty0, Ty1>(&mut State, ID, &BalanceManager, &TxContext): Balances * Balances
StLoc[4](loc0: Balances)
StLoc[6](loc2: Balances)
MoveLoc[5](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[6](loc2: Balances)
MoveLoc[4](loc0: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
Ret
}
public borrow_flashloan_base<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> * FlashLoan {
L3:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: &mut TxContext)
Call vault::borrow_flashloan_base<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, ID, u64, &mut TxContext): Coin<Ty0> * FlashLoan
Ret
}
public borrow_flashloan_quote<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: &mut TxContext): Coin<Ty1> * FlashLoan {
L3:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: &mut TxContext)
Call vault::borrow_flashloan_quote<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, ID, u64, &mut TxContext): Coin<Ty1> * FlashLoan
Ret
}
public return_flashloan_base<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty0>, Arg2: FlashLoan) {
L3:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[1](Arg1: Coin<Ty0>)
MoveLoc[2](Arg2: FlashLoan)
Call vault::return_flashloan_base<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, ID, Coin<Ty0>, FlashLoan)
Ret
}
public return_flashloan_quote<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Coin<Ty1>, Arg2: FlashLoan) {
L3:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[1](Arg1: Coin<Ty1>)
MoveLoc[2](Arg2: FlashLoan)
Call vault::return_flashloan_quote<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, ID, Coin<Ty1>, FlashLoan)
Ret
}
public add_deep_price_point<Ty0, Ty1, Ty2, Ty3>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Pool<Ty2, Ty3>, Arg2: &Clock) {
L3:	loc0: bool
L4:	loc1: bool
L5:	loc2: TypeName
L6:	loc3: bool
L7:	loc4: u64
L8:	loc5: u64
L9:	loc6: TypeName
L10:	loc7: TypeName
L11:	loc8: bool
L12:	loc9: bool
L13:	loc10: bool
L14:	loc11: TypeName
L15:	loc12: u64
L16:	loc13: TypeName
L17:	loc14: TypeName
L18:	loc15: &mut PoolInner<Ty0, Ty1>
L19:	loc16: TypeName
L20:	loc17: u64
B0:
CopyLoc[1](Arg1: &Pool<Ty2, Ty3>)
Call whitelisted<Ty2, Ty3>(&Pool<Ty2, Ty3>): bool
BrFalse(7)
B1:
CopyLoc[1](Arg1: &Pool<Ty2, Ty3>)
Call registered_pool<Ty2, Ty3>(&Pool<Ty2, Ty3>): bool
StLoc[3](loc0: bool)
Branch(9)
B2:
LdFalse
StLoc[3](loc0: bool)
B3:
MoveLoc[3](loc0: bool)
BrFalse(12)
B4:
Branch(20)
B5:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Pop
MoveLoc[1](Arg1: &Pool<Ty2, Ty3>)
Pop
MoveLoc[2](Arg2: &Clock)
Pop
LdConst[6](u64: 7)
Abort
B6:
CopyLoc[1](Arg1: &Pool<Ty2, Ty3>)
CopyLoc[2](Arg2: &Clock)
Call mid_price<Ty2, Ty3>(&Pool<Ty2, Ty3>, &Clock): u64
StLoc[15](loc12: u64)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[18](loc15: &mut PoolInner<Ty0, Ty1>)
Call type_name::get<Ty2>(): TypeName
StLoc[10](loc7: TypeName)
Call type_name::get<Ty3>(): TypeName
StLoc[16](loc13: TypeName)
Call type_name::get<Ty0>(): TypeName
StLoc[17](loc14: TypeName)
Call type_name::get<Ty1>(): TypeName
StLoc[19](loc16: TypeName)
Call type_name::get<DEEP>(): TypeName
StLoc[9](loc6: TypeName)
MoveLoc[2](Arg2: &Clock)
Call clock::timestamp_ms(&Clock): u64
StLoc[20](loc17: u64)
CopyLoc[10](loc7: TypeName)
CopyLoc[9](loc6: TypeName)
Eq
BrFalse(47)
B7:
LdTrue
StLoc[4](loc1: bool)
Branch(51)
B8:
CopyLoc[16](loc13: TypeName)
CopyLoc[9](loc6: TypeName)
Eq
StLoc[4](loc1: bool)
B9:
MoveLoc[4](loc1: bool)
BrFalse(54)
B10:
Branch(60)
B11:
MoveLoc[18](loc15: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[1](Arg1: &Pool<Ty2, Ty3>)
Pop
LdConst[8](u64: 10)
Abort
B12:
CopyLoc[10](loc7: TypeName)
MoveLoc[9](loc6: TypeName)
Eq
StLoc[11](loc8: bool)
CopyLoc[11](loc8: bool)
BrFalse(69)
B13:
MoveLoc[16](loc13: TypeName)
StLoc[5](loc2: TypeName)
Branch(71)
B14:
MoveLoc[10](loc7: TypeName)
StLoc[5](loc2: TypeName)
B15:
MoveLoc[5](loc2: TypeName)
StLoc[14](loc11: TypeName)
CopyLoc[14](loc11: TypeName)
MoveLoc[17](loc14: TypeName)
Eq
StLoc[12](loc9: bool)
MoveLoc[14](loc11: TypeName)
MoveLoc[19](loc16: TypeName)
Eq
StLoc[13](loc10: bool)
CopyLoc[12](loc9: bool)
BrFalse(86)
B16:
LdTrue
StLoc[6](loc3: bool)
Branch(88)
B17:
MoveLoc[13](loc10: bool)
StLoc[6](loc3: bool)
B18:
MoveLoc[6](loc3: bool)
BrFalse(91)
B19:
Branch(97)
B20:
MoveLoc[18](loc15: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[1](Arg1: &Pool<Ty2, Ty3>)
Pop
LdConst[8](u64: 10)
Abort
B21:
MoveLoc[11](loc8: bool)
BrFalse(104)
B22:
LdU64(1000000000)
MoveLoc[15](loc12: u64)
Call math::div(u64, u64): u64
StLoc[7](loc4: u64)
Branch(106)
B23:
MoveLoc[15](loc12: u64)
StLoc[7](loc4: u64)
B24:
MoveLoc[7](loc4: u64)
StLoc[8](loc5: u64)
CopyLoc[18](loc15: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[4](PoolInner.deep_price: DeepPrice)
CopyLoc[8](loc5: u64)
CopyLoc[20](loc17: u64)
CopyLoc[12](loc9: bool)
Call deep_price::add_price_point(&mut DeepPrice, u64, u64, bool)
MoveLoc[8](loc5: u64)
MoveLoc[20](loc17: u64)
MoveLoc[12](loc9: bool)
MoveLoc[1](Arg1: &Pool<Ty2, Ty3>)
Call load_inner<Ty2, Ty3>(&Pool<Ty2, Ty3>): &PoolInner<Ty2, Ty3>
ImmBorrowFieldGeneric[5](PoolInner.pool_id: ID)
ReadRef
MoveLoc[18](loc15: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
Call deep_price::emit_deep_price_added(u64, u64, bool, ID, ID)
Ret
}
public burn_deep<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut ProtectedTreasury, Arg2: &mut TxContext): u64 {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: Coin<DEEP>
L6:	loc3: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[6](loc3: &mut PoolInner<Ty0, Ty1>)
CopyLoc[6](loc3: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
Call state::history_mut(&mut State): &mut History
Call history::reset_balance_to_burn(&mut History): u64
StLoc[4](loc1: u64)
CopyLoc[6](loc3: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[4](loc1: u64)
Call vault::withdraw_deep_to_burn<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, u64): Balance<DEEP>
MoveLoc[2](Arg2: &mut TxContext)
Call coin::from_balance<DEEP>(Balance<DEEP>, &mut TxContext): Coin<DEEP>
StLoc[5](loc2: Coin<DEEP>)
ImmBorrowLoc[5](loc2: Coin<DEEP>)
Call coin::value<DEEP>(&Coin<DEEP>): u64
StLoc[3](loc0: u64)
MoveLoc[1](Arg1: &mut ProtectedTreasury)
MoveLoc[5](loc2: Coin<DEEP>)
Call deep::burn(&mut ProtectedTreasury, Coin<DEEP>)
MoveLoc[6](loc3: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[3](loc0: u64)
PackGeneric[0](DeepBurned<Ty0, Ty1>)
Call event::emit<DeepBurned<Ty0, Ty1>>(DeepBurned<Ty0, Ty1>)
MoveLoc[3](loc0: u64)
Ret
}
public create_pool_admin<Ty0, Ty1>(Arg0: &mut Registry, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: bool, Arg5: bool, Arg6: &DeepbookAdminCap, Arg7: &mut TxContext): ID {
L8:	loc0: Coin<DEEP>
B0:
CopyLoc[7](Arg7: &mut TxContext)
Call coin::zero<DEEP>(&mut TxContext): Coin<DEEP>
StLoc[8](loc0: Coin<DEEP>)
MoveLoc[0](Arg0: &mut Registry)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
MoveLoc[3](Arg3: u64)
MoveLoc[8](loc0: Coin<DEEP>)
MoveLoc[4](Arg4: bool)
MoveLoc[5](Arg5: bool)
MoveLoc[7](Arg7: &mut TxContext)
Call create_pool<Ty0, Ty1>(&mut Registry, u64, u64, u64, Coin<DEEP>, bool, bool, &mut TxContext): ID
Ret
}
public unregister_pool_admin<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut Registry, Arg2: &DeepbookAdminCap) {
L3:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[6](PoolInner.registered_pool: bool)
ReadRef
BrFalse(8)
B1:
Branch(14)
B2:
MoveLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[1](Arg1: &mut Registry)
Pop
LdConst[12](u64: 14)
Abort
B3:
LdFalse
MoveLoc[3](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[6](PoolInner.registered_pool: bool)
WriteRef
MoveLoc[1](Arg1: &mut Registry)
Call registry::unregister_pool<Ty0, Ty1>(&mut Registry)
Ret
}
public update_allowed_versions<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Registry, Arg2: &DeepbookAdminCap) {
L3:	loc0: VecSet<u64>
L4:	loc1: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[1](Arg1: &Registry)
Call registry::allowed_versions(&Registry): VecSet<u64>
StLoc[3](loc0: VecSet<u64>)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
MutBorrowFieldGeneric[7](Pool.inner: Versioned)
Call versioned::load_value_mut<PoolInner<Ty0, Ty1>>(&mut Versioned): &mut PoolInner<Ty0, Ty1>
StLoc[4](loc1: &mut PoolInner<Ty0, Ty1>)
MoveLoc[3](loc0: VecSet<u64>)
MoveLoc[4](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[8](PoolInner.allowed_versions: VecSet<u64>)
WriteRef
Ret
}
public adjust_tick_size_admin<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: &DeepbookAdminCap, Arg3: &Clock) {
L4:	loc0: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
CopyLoc[1](Arg1: u64)
LdU64(0)
Gt
BrFalse(8)
B1:
Branch(14)
B2:
MoveLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &Clock)
Pop
LdConst[2](u64: 3)
Abort
B3:
CopyLoc[1](Arg1: u64)
Call math::is_power_of_ten(u64): bool
BrFalse(18)
B4:
Branch(24)
B5:
MoveLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &Clock)
Pop
LdConst[2](u64: 3)
Abort
B6:
CopyLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: u64)
Call book::set_tick_size(&mut Book, u64)
CopyLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::tick_size(&Book): u64
CopyLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
MoveLoc[4](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::min_size(&Book): u64
MoveLoc[3](Arg3: &Clock)
Call clock::timestamp_ms(&Clock): u64
PackGeneric[1](BookParamsUpdated<Ty0, Ty1>)
Call event::emit<BookParamsUpdated<Ty0, Ty1>>(BookParamsUpdated<Ty0, Ty1>)
Ret
}
public adjust_min_lot_size_admin<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: &DeepbookAdminCap, Arg4: &Clock) {
L5:	loc0: u64
L6:	loc1: &mut PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
StLoc[5](loc0: u64)
CopyLoc[1](Arg1: u64)
LdU64(0)
Gt
BrFalse(12)
B1:
Branch(18)
B2:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
LdConst[3](u64: 4)
Abort
B3:
MoveLoc[5](loc0: u64)
CopyLoc[1](Arg1: u64)
Mod
LdU64(0)
Eq
BrFalse(25)
B4:
Branch(31)
B5:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
LdConst[3](u64: 4)
Abort
B6:
CopyLoc[1](Arg1: u64)
Call math::is_power_of_ten(u64): bool
BrFalse(35)
B7:
Branch(41)
B8:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
LdConst[3](u64: 4)
Abort
B9:
CopyLoc[2](Arg2: u64)
LdU64(0)
Gt
BrFalse(46)
B10:
Branch(52)
B11:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
LdConst[4](u64: 5)
Abort
B12:
CopyLoc[2](Arg2: u64)
CopyLoc[1](Arg1: u64)
Mod
LdU64(0)
Eq
BrFalse(59)
B13:
Branch(65)
B14:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
LdConst[4](u64: 5)
Abort
B15:
CopyLoc[2](Arg2: u64)
Call math::is_power_of_ten(u64): bool
BrFalse(69)
B16:
Branch(75)
B17:
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
Pop
MoveLoc[4](Arg4: &Clock)
Pop
LdConst[4](u64: 5)
Abort
B18:
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: u64)
Call book::set_lot_size(&mut Book, u64)
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[2](Arg2: u64)
Call book::set_min_size(&mut Book, u64)
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::tick_size(&Book): u64
CopyLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
MoveLoc[6](loc1: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::min_size(&Book): u64
MoveLoc[4](Arg4: &Clock)
Call clock::timestamp_ms(&Clock): u64
PackGeneric[1](BookParamsUpdated<Ty0, Ty1>)
Call event::emit<BookParamsUpdated<Ty0, Ty1>>(BookParamsUpdated<Ty0, Ty1>)
Ret
}
public whitelisted<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::whitelisted(&Governance): bool
Ret
}
public stable_pool<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::stable(&Governance): bool
Ret
}
public registered_pool<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): bool {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[6](PoolInner.registered_pool: bool)
ReadRef
Ret
}
public get_quote_quantity_out<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: &Clock): u64 * u64 * u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
MoveLoc[1](Arg1: u64)
LdU64(0)
MoveLoc[2](Arg2: &Clock)
Call get_quantity_out<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64, u64, &Clock): u64 * u64 * u64
Ret
}
public get_base_quantity_out<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: &Clock): u64 * u64 * u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
LdU64(0)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: &Clock)
Call get_quantity_out<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64, u64, &Clock): u64 * u64 * u64
Ret
}
public get_quote_quantity_out_input_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: &Clock): u64 * u64 * u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
MoveLoc[1](Arg1: u64)
LdU64(0)
MoveLoc[2](Arg2: &Clock)
Call get_quantity_out_input_fee<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64, u64, &Clock): u64 * u64 * u64
Ret
}
public get_base_quantity_out_input_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: &Clock): u64 * u64 * u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
LdU64(0)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: &Clock)
Call get_quantity_out_input_fee<Ty0, Ty1>(&Pool<Ty0, Ty1>, u64, u64, &Clock): u64 * u64 * u64
Ret
}
public get_quantity_out<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: &Clock): u64 * u64 * u64 {
L4:	loc0: OrderDeepPrice
L5:	loc1: TradeParams
L6:	loc2: &PoolInner<Ty0, Ty1>
L7:	loc3: u64
L8:	loc4: bool
B0:
CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call whitelisted<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
StLoc[8](loc4: bool)
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[6](loc2: &PoolInner<Ty0, Ty1>)
CopyLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[5](loc1: TradeParams)
ImmBorrowLoc[5](loc1: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
ImmBorrowLoc[5](loc1: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
Pop
StLoc[7](loc3: u64)
CopyLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[4](PoolInner.deep_price: DeepPrice)
MoveLoc[8](loc4: bool)
Call deep_price::get_order_deep_price(&DeepPrice, bool): OrderDeepPrice
StLoc[4](loc0: OrderDeepPrice)
CopyLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
MoveLoc[7](loc3: u64)
MoveLoc[4](loc0: OrderDeepPrice)
MoveLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
LdTrue
MoveLoc[3](Arg3: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::get_quantity_out(&Book, u64, u64, u64, OrderDeepPrice, u64, bool, u64): u64 * u64 * u64
Ret
}
public get_quantity_out_input_fee<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: &Clock): u64 * u64 * u64 {
L4:	loc0: OrderDeepPrice
L5:	loc1: TradeParams
L6:	loc2: &PoolInner<Ty0, Ty1>
L7:	loc3: u64
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[6](loc2: &PoolInner<Ty0, Ty1>)
CopyLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[5](loc1: TradeParams)
ImmBorrowLoc[5](loc1: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
ImmBorrowLoc[5](loc1: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
Pop
StLoc[7](loc3: u64)
CopyLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[4](PoolInner.deep_price: DeepPrice)
Call deep_price::empty_deep_price(&DeepPrice): OrderDeepPrice
StLoc[4](loc0: OrderDeepPrice)
CopyLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
MoveLoc[7](loc3: u64)
MoveLoc[4](loc0: OrderDeepPrice)
MoveLoc[6](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
LdFalse
MoveLoc[3](Arg3: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::get_quantity_out(&Book, u64, u64, u64, OrderDeepPrice, u64, bool, u64): u64 * u64 * u64
Ret
}
public mid_price<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &Clock): u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::mid_price(&Book, u64): u64
Ret
}
public account_open_orders<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &BalanceManager): VecSet<u128> {
L2:	loc0: &PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[2](loc0: &PoolInner<Ty0, Ty1>)
CopyLoc[2](loc0: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[1](Arg1: &BalanceManager)
Call balance_manager::id(&BalanceManager): ID
Call state::account_exists(&State, ID): bool
Not
BrFalse(16)
B1:
MoveLoc[2](loc0: &PoolInner<Ty0, Ty1>)
Pop
MoveLoc[1](Arg1: &BalanceManager)
Pop
Call vec_set::empty<u128>(): VecSet<u128>
Ret
B2:
MoveLoc[2](loc0: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
MoveLoc[1](Arg1: &BalanceManager)
Call balance_manager::id(&BalanceManager): ID
Call state::account(&State, ID): &Account
Call account::open_orders(&Account): VecSet<u128>
Ret
}
public get_level2_range<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64, Arg3: bool, Arg4: &Clock): vector<u64> * vector<u64> {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
Call constants::max_u64(): u64
MoveLoc[3](Arg3: bool)
MoveLoc[4](Arg4: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::get_level2_range_and_ticks(&Book, u64, u64, u64, bool, u64): vector<u64> * vector<u64>
Ret
}
public get_level2_ticks_from_mid<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: &Clock): vector<u64> * vector<u64> * vector<u64> * vector<u64> {
L3:	loc0: vector<u64>
L4:	loc1: vector<u64>
L5:	loc2: vector<u64>
L6:	loc3: vector<u64>
L7:	loc4: &PoolInner<Ty0, Ty1>
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[7](loc4: &PoolInner<Ty0, Ty1>)
CopyLoc[7](loc4: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call constants::min_price(): u64
Call constants::max_price(): u64
CopyLoc[1](Arg1: u64)
LdTrue
CopyLoc[2](Arg2: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::get_level2_range_and_ticks(&Book, u64, u64, u64, bool, u64): vector<u64> * vector<u64>
StLoc[6](loc3: vector<u64>)
StLoc[5](loc2: vector<u64>)
MoveLoc[7](loc4: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call constants::min_price(): u64
Call constants::max_price(): u64
MoveLoc[1](Arg1: u64)
LdFalse
MoveLoc[2](Arg2: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::get_level2_range_and_ticks(&Book, u64, u64, u64, bool, u64): vector<u64> * vector<u64>
StLoc[4](loc1: vector<u64>)
StLoc[3](loc0: vector<u64>)
MoveLoc[5](loc2: vector<u64>)
MoveLoc[6](loc3: vector<u64>)
MoveLoc[3](loc0: vector<u64>)
MoveLoc[4](loc1: vector<u64>)
Ret
}
public vault_balances<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 * u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
Call vault::balances<Ty0, Ty1>(&Vault<Ty0, Ty1>): u64 * u64 * u64
Ret
}
public get_pool_id_by_asset<Ty0, Ty1>(Arg0: &Registry): ID {
B0:
MoveLoc[0](Arg0: &Registry)
Call registry::get_pool_id<Ty0, Ty1>(&Registry): ID
Ret
}
public get_order<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u128): Order {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
MoveLoc[1](Arg1: u128)
Call book::get_order(&Book, u128): Order
Ret
}
public get_orders<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: vector<u128>): vector<Order> {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u128
L5:	loc3: vector<Order>
B0:
VecPack(45, 0)
StLoc[5](loc3: vector<Order>)
LdU64(0)
StLoc[2](loc0: u64)
ImmBorrowLoc[1](Arg1: vector<u128>)
VecLen(100)
StLoc[3](loc1: u64)
B1:
CopyLoc[2](loc0: u64)
CopyLoc[3](loc1: u64)
Lt
BrFalse(27)
B2:
Branch(12)
B3:
ImmBorrowLoc[1](Arg1: vector<u128>)
CopyLoc[2](loc0: u64)
VecImmBorrow(100)
ReadRef
StLoc[4](loc2: u128)
MutBorrowLoc[5](loc3: vector<Order>)
CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
MoveLoc[4](loc2: u128)
Call get_order<Ty0, Ty1>(&Pool<Ty0, Ty1>, u128): Order
VecPushBack(45)
MoveLoc[2](loc0: u64)
LdU64(1)
Add
StLoc[2](loc0: u64)
Branch(7)
B4:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Pop
MoveLoc[5](loc3: vector<Order>)
Ret
}
public get_account_order_details<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &BalanceManager): vector<Order> {
L2:	loc0: vector<u128>
B0:
CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
MoveLoc[1](Arg1: &BalanceManager)
Call account_open_orders<Ty0, Ty1>(&Pool<Ty0, Ty1>, &BalanceManager): VecSet<u128>
Call vec_set::into_keys<u128>(VecSet<u128>): vector<u128>
StLoc[2](loc0: vector<u128>)
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
MoveLoc[2](loc0: vector<u128>)
Call get_orders<Ty0, Ty1>(&Pool<Ty0, Ty1>, vector<u128>): vector<Order>
Ret
}
public get_order_deep_price<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): OrderDeepPrice {
L1:	loc0: bool
B0:
CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call whitelisted<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
StLoc[1](loc0: bool)
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[4](PoolInner.deep_price: DeepPrice)
MoveLoc[1](loc0: bool)
Call deep_price::get_order_deep_price(&DeepPrice, bool): OrderDeepPrice
Ret
}
public get_order_deep_required<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: u64, Arg2: u64): u64 * u64 {
L3:	loc0: TradeParams
L4:	loc1: TradeParams
L5:	loc2: Balances
L6:	loc3: u64
L7:	loc4: u64
L8:	loc5: OrderDeepPrice
L9:	loc6: &PoolInner<Ty0, Ty1>
L10:	loc7: u64
B0:
CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call get_order_deep_price<Ty0, Ty1>(&Pool<Ty0, Ty1>): OrderDeepPrice
StLoc[8](loc5: OrderDeepPrice)
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[9](loc6: &PoolInner<Ty0, Ty1>)
CopyLoc[9](loc6: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[3](loc0: TradeParams)
ImmBorrowLoc[3](loc0: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
StLoc[7](loc4: u64)
MoveLoc[9](loc6: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[4](loc1: TradeParams)
ImmBorrowLoc[4](loc1: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
StLoc[10](loc7: u64)
ImmBorrowLoc[8](loc5: OrderDeepPrice)
CopyLoc[1](Arg1: u64)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
Call math::mul(u64, u64): u64
LdTrue
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[5](loc2: Balances)
ImmBorrowLoc[5](loc2: Balances)
Call balances::deep(&Balances): u64
StLoc[6](loc3: u64)
MoveLoc[10](loc7: u64)
CopyLoc[6](loc3: u64)
Call math::mul(u64, u64): u64
MoveLoc[7](loc4: u64)
MoveLoc[6](loc3: u64)
Call math::mul(u64, u64): u64
Ret
}
public locked_balance<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &BalanceManager): u64 * u64 * u64 {
L2:	loc0: u64
L3:	loc1: vector<Order>
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: u64
L8:	loc6: Balances
L9:	loc7: u64
L10:	loc8: &Order
L11:	loc9: u64
L12:	loc10: &PoolInner<Ty0, Ty1>
L13:	loc11: Balances
L14:	loc12: u64
L15:	loc13: &vector<Order>
B0:
CopyLoc[0](Arg0: &Pool<Ty0, Ty1>)
CopyLoc[1](Arg1: &BalanceManager)
Call get_account_order_details<Ty0, Ty1>(&Pool<Ty0, Ty1>, &BalanceManager): vector<Order>
StLoc[3](loc1: vector<Order>)
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[12](loc10: &PoolInner<Ty0, Ty1>)
CopyLoc[12](loc10: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
CopyLoc[1](Arg1: &BalanceManager)
Call balance_manager::id(&BalanceManager): ID
Call state::account_exists(&State, ID): bool
Not
BrFalse(22)
B1:
MoveLoc[12](loc10: &PoolInner<Ty0, Ty1>)
Pop
MoveLoc[1](Arg1: &BalanceManager)
Pop
LdU64(0)
LdU64(0)
LdU64(0)
Ret
B2:
LdU64(0)
StLoc[4](loc2: u64)
LdU64(0)
StLoc[11](loc9: u64)
LdU64(0)
StLoc[5](loc3: u64)
ImmBorrowLoc[3](loc1: vector<Order>)
StLoc[15](loc13: &vector<Order>)
CopyLoc[15](loc13: &vector<Order>)
VecLen(45)
StLoc[2](loc0: u64)
LdU64(0)
StLoc[6](loc4: u64)
MoveLoc[2](loc0: u64)
StLoc[14](loc12: u64)
B3:
CopyLoc[6](loc4: u64)
CopyLoc[14](loc12: u64)
Lt
BrFalse(78)
B4:
CopyLoc[6](loc4: u64)
StLoc[7](loc5: u64)
CopyLoc[15](loc13: &vector<Order>)
MoveLoc[7](loc5: u64)
VecImmBorrow(45)
StLoc[10](loc8: &Order)
CopyLoc[12](loc10: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::history(&State): &History
CopyLoc[10](loc8: &Order)
Call order::epoch(&Order): u64
Call history::historic_maker_fee(&History, u64): u64
StLoc[9](loc7: u64)
MoveLoc[10](loc8: &Order)
MoveLoc[9](loc7: u64)
Call order::locked_balance(&Order, u64): Balances
StLoc[8](loc6: Balances)
MoveLoc[4](loc2: u64)
ImmBorrowLoc[8](loc6: Balances)
Call balances::base(&Balances): u64
Add
StLoc[4](loc2: u64)
MoveLoc[11](loc9: u64)
ImmBorrowLoc[8](loc6: Balances)
Call balances::quote(&Balances): u64
Add
StLoc[11](loc9: u64)
MoveLoc[5](loc3: u64)
ImmBorrowLoc[8](loc6: Balances)
Call balances::deep(&Balances): u64
Add
StLoc[5](loc3: u64)
MoveLoc[6](loc4: u64)
LdU64(1)
Add
StLoc[6](loc4: u64)
Branch(37)
B5:
MoveLoc[15](loc13: &vector<Order>)
Pop
MoveLoc[12](loc10: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
MoveLoc[1](Arg1: &BalanceManager)
Call balance_manager::id(&BalanceManager): ID
Call state::account(&State, ID): &Account
Call account::settled_balances(&Account): Balances
StLoc[13](loc11: Balances)
MoveLoc[4](loc2: u64)
ImmBorrowLoc[13](loc11: Balances)
Call balances::base(&Balances): u64
Add
StLoc[4](loc2: u64)
MoveLoc[11](loc9: u64)
ImmBorrowLoc[13](loc11: Balances)
Call balances::quote(&Balances): u64
Add
StLoc[11](loc9: u64)
MoveLoc[5](loc3: u64)
ImmBorrowLoc[13](loc11: Balances)
Call balances::deep(&Balances): u64
Add
StLoc[5](loc3: u64)
MoveLoc[4](loc2: u64)
MoveLoc[11](loc9: u64)
MoveLoc[5](loc3: u64)
Ret
}
public pool_trade_params<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 * u64 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: TradeParams
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[4](loc3: TradeParams)
ImmBorrowLoc[4](loc3: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
StLoc[3](loc2: u64)
ImmBorrowLoc[4](loc3: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
StLoc[1](loc0: u64)
ImmBorrowLoc[4](loc3: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
StLoc[2](loc1: u64)
MoveLoc[3](loc2: u64)
MoveLoc[1](loc0: u64)
MoveLoc[2](loc1: u64)
Ret
}
public pool_trade_params_next<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 * u64 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: TradeParams
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::next_trade_params(&Governance): TradeParams
StLoc[4](loc3: TradeParams)
ImmBorrowLoc[4](loc3: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
StLoc[3](loc2: u64)
ImmBorrowLoc[4](loc3: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
StLoc[1](loc0: u64)
ImmBorrowLoc[4](loc3: TradeParams)
Call trade_params::stake_required(&TradeParams): u64
StLoc[2](loc1: u64)
MoveLoc[3](loc2: u64)
MoveLoc[1](loc0: u64)
MoveLoc[2](loc1: u64)
Ret
}
public pool_book_params<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 * u64 * u64 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: &PoolInner<Ty0, Ty1>
L4:	loc3: u64
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
StLoc[3](loc2: &PoolInner<Ty0, Ty1>)
CopyLoc[3](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::tick_size(&Book): u64
StLoc[4](loc3: u64)
CopyLoc[3](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::lot_size(&Book): u64
StLoc[1](loc0: u64)
MoveLoc[3](loc2: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::min_size(&Book): u64
StLoc[2](loc1: u64)
MoveLoc[4](loc3: u64)
MoveLoc[1](loc0: u64)
MoveLoc[2](loc1: u64)
Ret
}
public account<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>, Arg1: &BalanceManager): Account {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
MoveLoc[1](Arg1: &BalanceManager)
Call balance_manager::id(&BalanceManager): ID
Call state::account(&State, ID): &Account
ReadRef
Ret
}
public quorum<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): u64 {
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
Call load_inner<Ty0, Ty1>(&Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1>
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::quorum(&Governance): u64
Ret
}
public(friend) create_pool<Ty0, Ty1>(Arg0: &mut Registry, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: Coin<DEEP>, Arg5: bool, Arg6: bool, Arg7: &mut TxContext): ID {
L8:	loc0: bool
L9:	loc1: u64
L10:	loc2: TradeParams
L11:	loc3: Pool<Ty0, Ty1>
L12:	loc4: UID
L13:	loc5: ID
L14:	loc6: PoolInner<Ty0, Ty1>
L15:	loc7: u64
L16:	loc8: address
B0:
CopyLoc[1](Arg1: u64)
LdU64(0)
Gt
BrFalse(5)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[2](u64: 3)
Abort
B3:
CopyLoc[1](Arg1: u64)
Call math::is_power_of_ten(u64): bool
BrFalse(15)
B4:
Branch(21)
B5:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[2](u64: 3)
Abort
B6:
CopyLoc[2](Arg2: u64)
LdU64(1000)
Ge
BrFalse(26)
B7:
Branch(32)
B8:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[3](u64: 4)
Abort
B9:
CopyLoc[2](Arg2: u64)
Call math::is_power_of_ten(u64): bool
BrFalse(36)
B10:
Branch(42)
B11:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[3](u64: 4)
Abort
B12:
CopyLoc[3](Arg3: u64)
LdU64(0)
Gt
BrFalse(47)
B13:
Branch(53)
B14:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[4](u64: 5)
Abort
B15:
CopyLoc[3](Arg3: u64)
CopyLoc[2](Arg2: u64)
Mod
LdU64(0)
Eq
BrFalse(60)
B16:
Branch(66)
B17:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[4](u64: 5)
Abort
B18:
CopyLoc[3](Arg3: u64)
Call math::is_power_of_ten(u64): bool
BrFalse(70)
B19:
Branch(76)
B20:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[4](u64: 5)
Abort
B21:
CopyLoc[5](Arg5: bool)
BrFalse(81)
B22:
CopyLoc[6](Arg6: bool)
StLoc[8](loc0: bool)
Branch(83)
B23:
LdFalse
StLoc[8](loc0: bool)
B24:
MoveLoc[8](loc0: bool)
Not
BrFalse(87)
B25:
Branch(93)
B26:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[13](u64: 15)
Abort
B27:
Call type_name::get<Ty0>(): TypeName
Call type_name::get<Ty1>(): TypeName
Neq
BrFalse(98)
B28:
Branch(104)
B29:
MoveLoc[0](Arg0: &mut Registry)
Pop
MoveLoc[7](Arg7: &mut TxContext)
Pop
LdConst[1](u64: 2)
Abort
B30:
CopyLoc[7](Arg7: &mut TxContext)
Call object::new(&mut TxContext): UID
StLoc[12](loc4: UID)
CopyLoc[0](Arg0: &mut Registry)
FreezeRef
Call registry::allowed_versions(&Registry): VecSet<u64>
ImmBorrowLoc[12](loc4: UID)
Call object::uid_to_inner(&UID): ID
CopyLoc[1](Arg1: u64)
CopyLoc[2](Arg2: u64)
CopyLoc[3](Arg3: u64)
CopyLoc[7](Arg7: &mut TxContext)
Call book::empty(u64, u64, u64, &mut TxContext): Book
MoveLoc[6](Arg6: bool)
CopyLoc[7](Arg7: &mut TxContext)
Call state::empty(bool, &mut TxContext): State
Call vault::empty<Ty0, Ty1>(): Vault<Ty0, Ty1>
Call deep_price::empty(): DeepPrice
LdTrue
PackGeneric[2](PoolInner<Ty0, Ty1>)
StLoc[14](loc6: PoolInner<Ty0, Ty1>)
CopyLoc[5](Arg5: bool)
BrFalse(131)
B31:
MutBorrowLoc[14](loc6: PoolInner<Ty0, Ty1>)
CopyLoc[7](Arg7: &mut TxContext)
FreezeRef
Call set_whitelist<Ty0, Ty1>(&mut PoolInner<Ty0, Ty1>, &TxContext)
B32:
ImmBorrowLoc[14](loc6: PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](PoolInner.state: State)
Call state::governance(&State): &Governance
Call governance::trade_params(&Governance): TradeParams
StLoc[10](loc2: TradeParams)
ImmBorrowLoc[10](loc2: TradeParams)
Call trade_params::taker_fee(&TradeParams): u64
StLoc[15](loc7: u64)
ImmBorrowLoc[10](loc2: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
StLoc[9](loc1: u64)
CopyLoc[0](Arg0: &mut Registry)
FreezeRef
Call registry::treasury_address(&Registry): address
StLoc[16](loc8: address)
MoveLoc[12](loc4: UID)
Call constants::current_version(): u64
MoveLoc[14](loc6: PoolInner<Ty0, Ty1>)
MoveLoc[7](Arg7: &mut TxContext)
Call versioned::create<PoolInner<Ty0, Ty1>>(u64, PoolInner<Ty0, Ty1>, &mut TxContext): Versioned
PackGeneric[3](Pool<Ty0, Ty1>)
StLoc[11](loc3: Pool<Ty0, Ty1>)
ImmBorrowLoc[11](loc3: Pool<Ty0, Ty1>)
Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
StLoc[13](loc5: ID)
MoveLoc[0](Arg0: &mut Registry)
CopyLoc[13](loc5: ID)
Call registry::register_pool<Ty0, Ty1>(&mut Registry, ID)
CopyLoc[13](loc5: ID)
MoveLoc[15](loc7: u64)
MoveLoc[9](loc1: u64)
MoveLoc[1](Arg1: u64)
MoveLoc[2](Arg2: u64)
MoveLoc[3](Arg3: u64)
MoveLoc[5](Arg5: bool)
CopyLoc[16](loc8: address)
PackGeneric[4](PoolCreated<Ty0, Ty1>)
Call event::emit<PoolCreated<Ty0, Ty1>>(PoolCreated<Ty0, Ty1>)
MoveLoc[4](Arg4: Coin<DEEP>)
MoveLoc[16](loc8: address)
Call transfer::public_transfer<Coin<DEEP>>(Coin<DEEP>, address)
MoveLoc[11](loc3: Pool<Ty0, Ty1>)
Call transfer::share_object<Pool<Ty0, Ty1>>(Pool<Ty0, Ty1>)
MoveLoc[13](loc5: ID)
Ret
}
public(friend) bids<Ty0, Ty1>(Arg0: &PoolInner<Ty0, Ty1>): &BigVector<Order> {
B0:
MoveLoc[0](Arg0: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::bids(&Book): &BigVector<Order>
Ret
}
public(friend) asks<Ty0, Ty1>(Arg0: &PoolInner<Ty0, Ty1>): &BigVector<Order> {
B0:
MoveLoc[0](Arg0: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](PoolInner.book: Book)
Call book::asks(&Book): &BigVector<Order>
Ret
}
public(friend) load_inner<Ty0, Ty1>(Arg0: &Pool<Ty0, Ty1>): &PoolInner<Ty0, Ty1> {
L1:	loc0: &PoolInner<Ty0, Ty1>
L2:	loc1: u64
B0:
MoveLoc[0](Arg0: &Pool<Ty0, Ty1>)
ImmBorrowFieldGeneric[7](Pool.inner: Versioned)
Call versioned::load_value<PoolInner<Ty0, Ty1>>(&Versioned): &PoolInner<Ty0, Ty1>
StLoc[1](loc0: &PoolInner<Ty0, Ty1>)
Call constants::current_version(): u64
StLoc[2](loc1: u64)
CopyLoc[1](loc0: &PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[8](PoolInner.allowed_versions: VecSet<u64>)
ImmBorrowLoc[2](loc1: u64)
Call vec_set::contains<u64>(&VecSet<u64>, &u64): bool
BrFalse(12)
B1:
Branch(16)
B2:
MoveLoc[1](loc0: &PoolInner<Ty0, Ty1>)
Pop
LdConst[9](u64: 11)
Abort
B3:
MoveLoc[1](loc0: &PoolInner<Ty0, Ty1>)
Ret
}
public(friend) load_inner_mut<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1> {
L1:	loc0: &mut PoolInner<Ty0, Ty1>
L2:	loc1: u64
B0:
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
MutBorrowFieldGeneric[7](Pool.inner: Versioned)
Call versioned::load_value_mut<PoolInner<Ty0, Ty1>>(&mut Versioned): &mut PoolInner<Ty0, Ty1>
StLoc[1](loc0: &mut PoolInner<Ty0, Ty1>)
Call constants::current_version(): u64
StLoc[2](loc1: u64)
CopyLoc[1](loc0: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[8](PoolInner.allowed_versions: VecSet<u64>)
ImmBorrowLoc[2](loc1: u64)
Call vec_set::contains<u64>(&VecSet<u64>, &u64): bool
BrFalse(12)
B1:
Branch(16)
B2:
MoveLoc[1](loc0: &mut PoolInner<Ty0, Ty1>)
Pop
LdConst[9](u64: 11)
Abort
B3:
MoveLoc[1](loc0: &mut PoolInner<Ty0, Ty1>)
Ret
}
set_whitelist<Ty0, Ty1>(Arg0: &mut PoolInner<Ty0, Ty1>, Arg1: &TxContext) {
B0:
MoveLoc[0](Arg0: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
MoveLoc[1](Arg1: &TxContext)
Call state::governance_mut(&mut State, &TxContext): &mut Governance
LdTrue
Call governance::set_whitelist(&mut Governance, bool)
Ret
}
place_order_int<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &mut BalanceManager, Arg2: &TradeProof, Arg3: u64, Arg4: u8, Arg5: u8, Arg6: u64, Arg7: u64, Arg8: bool, Arg9: bool, Arg10: u64, Arg11: &Clock, Arg12: bool, Arg13: &TxContext): OrderInfo {
L14:	loc0: OrderDeepPrice
L15:	loc1: OrderDeepPrice
L16:	loc2: OrderInfo
L17:	loc3: Balances
L18:	loc4: &mut PoolInner<Ty0, Ty1>
L19:	loc5: Balances
L20:	loc6: bool
B0:
CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
FreezeRef
Call whitelisted<Ty0, Ty1>(&Pool<Ty0, Ty1>): bool
StLoc[20](loc6: bool)
MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
Call load_inner_mut<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): &mut PoolInner<Ty0, Ty1>
StLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
CopyLoc[9](Arg9: bool)
BrFalse(15)
B1:
CopyLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[4](PoolInner.deep_price: DeepPrice)
MoveLoc[20](loc6: bool)
Call deep_price::get_order_deep_price(&DeepPrice, bool): OrderDeepPrice
StLoc[14](loc0: OrderDeepPrice)
Branch(19)
B2:
CopyLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[4](PoolInner.deep_price: DeepPrice)
Call deep_price::empty_deep_price(&DeepPrice): OrderDeepPrice
StLoc[14](loc0: OrderDeepPrice)
B3:
MoveLoc[14](loc0: OrderDeepPrice)
StLoc[15](loc1: OrderDeepPrice)
CopyLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
CopyLoc[1](Arg1: &mut BalanceManager)
FreezeRef
Call balance_manager::id(&BalanceManager): ID
MoveLoc[3](Arg3: u64)
CopyLoc[13](Arg13: &TxContext)
Call tx_context::sender(&TxContext): address
MoveLoc[4](Arg4: u8)
MoveLoc[5](Arg5: u8)
MoveLoc[6](Arg6: u64)
MoveLoc[7](Arg7: u64)
MoveLoc[8](Arg8: bool)
MoveLoc[9](Arg9: bool)
CopyLoc[13](Arg13: &TxContext)
Call tx_context::epoch(&TxContext): u64
MoveLoc[10](Arg10: u64)
MoveLoc[15](loc1: OrderDeepPrice)
MoveLoc[12](Arg12: bool)
CopyLoc[11](Arg11: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call order_info::new(ID, ID, u64, address, u8, u8, u64, u64, bool, bool, u64, u64, OrderDeepPrice, bool, u64): OrderInfo
StLoc[16](loc2: OrderInfo)
CopyLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[1](PoolInner.book: Book)
MutBorrowLoc[16](loc2: OrderInfo)
CopyLoc[11](Arg11: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call book::create_order(&mut Book, &mut OrderInfo, u64)
CopyLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[0](PoolInner.state: State)
MutBorrowLoc[16](loc2: OrderInfo)
CopyLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](PoolInner.pool_id: ID)
ReadRef
MoveLoc[13](Arg13: &TxContext)
Call state::process_create(&mut State, &mut OrderInfo, ID, &TxContext): Balances * Balances
StLoc[17](loc3: Balances)
StLoc[19](loc5: Balances)
MoveLoc[18](loc4: &mut PoolInner<Ty0, Ty1>)
MutBorrowFieldGeneric[3](PoolInner.vault: Vault<Ty0, Ty1>)
MoveLoc[19](loc5: Balances)
MoveLoc[17](loc3: Balances)
MoveLoc[1](Arg1: &mut BalanceManager)
MoveLoc[2](Arg2: &TradeProof)
Call vault::settle_balance_manager<Ty0, Ty1>(&mut Vault<Ty0, Ty1>, Balances, Balances, &mut BalanceManager, &TradeProof)
ImmBorrowLoc[16](loc2: OrderInfo)
Call order_info::emit_order_info(&OrderInfo)
ImmBorrowLoc[16](loc2: OrderInfo)
MoveLoc[11](Arg11: &Clock)
Call clock::timestamp_ms(&Clock): u64
Call order_info::emit_orders_filled(&OrderInfo, u64)
MoveLoc[16](loc2: OrderInfo)
Ret
}
Constants [
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 6
=> u64: 7
=> u64: 9
=> u64: 10
=> u64: 11
=> u64: 12
=> u64: 13
=> u64: 14
=> u64: 15
=> vector<u128>: 00
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/state.mvb1012 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.state {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::account;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balance_manager;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::constants;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::deep_price;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::fill;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::governance;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::history;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::math;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order_info;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::trade_params;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use deeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep;
struct State has store {
	accounts: Table<ID, Account>,
	history: History,
	governance: Governance
}
struct StakeEvent has copy, drop {
	pool_id: ID,
	balance_manager_id: ID,
	epoch: u64,
	amount: u64,
	stake: bool
}
struct ProposalEvent has copy, drop {
	pool_id: ID,
	balance_manager_id: ID,
	epoch: u64,
	taker_fee: u64,
	maker_fee: u64,
	stake_required: u64
}
struct VoteEvent has copy, drop {
	pool_id: ID,
	balance_manager_id: ID,
	epoch: u64,
	from_proposal_id: Option<ID>,
	to_proposal_id: ID,
	stake: u64
}
struct RebateEventV2 has copy, drop {
	pool_id: ID,
	balance_manager_id: ID,
	epoch: u64,
	claim_amount: Balances
}
struct RebateEvent has copy, drop {
	pool_id: ID,
	balance_manager_id: ID,
	epoch: u64,
	claim_amount: u64
}
public(friend) empty(Arg0: bool, Arg1: &mut TxContext): State {
L2:	loc0: History
L3:	loc1: Governance
L4:	loc2: Governance
B0:
MoveLoc[0](Arg0: bool)
CopyLoc[1](Arg1: &mut TxContext)
FreezeRef
Call governance::empty(bool, &TxContext): Governance
StLoc[4](loc2: Governance)
ImmBorrowLoc[4](loc2: Governance)
Call governance::trade_params(&Governance): TradeParams
CopyLoc[1](Arg1: &mut TxContext)
FreezeRef
Call tx_context::epoch(&TxContext): u64
CopyLoc[1](Arg1: &mut TxContext)
Call history::empty(TradeParams, u64, &mut TxContext): History
StLoc[2](loc0: History)
MoveLoc[4](loc2: Governance)
StLoc[3](loc1: Governance)
MoveLoc[1](Arg1: &mut TxContext)
Call table::new<ID, Account>(&mut TxContext): Table<ID, Account>
MoveLoc[2](loc0: History)
MoveLoc[3](loc1: Governance)
Pack[0](State)
Ret
}
public(friend) process_create(Arg0: &mut State, Arg1: &mut OrderInfo, Arg2: ID, Arg3: &TxContext): Balances * Balances {
L4:	loc0: u64
L5:	loc1: OrderDeepPrice
L6:	loc2: TradeParams
L7:	loc3: TradeParams
L8:	loc4: VecSet<u128>
L9:	loc5: &mut Account
L10:	loc6: u64
L11:	loc7: u128
L12:	loc8: u128
L13:	loc9: u64
L14:	loc10: &mut vector<Fill>
L15:	loc11: u64
L16:	loc12: Balances
L17:	loc13: Balances
L18:	loc14: Balances
L19:	loc15: Balances
L20:	loc16: u64
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[3](Arg3: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
MoveLoc[2](Arg2: ID)
CopyLoc[3](Arg3: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[1](Arg1: &mut OrderInfo)
Call order_info::fills_ref(&mut OrderInfo): &mut vector<Fill>
StLoc[14](loc10: &mut vector<Fill>)
CopyLoc[0](Arg0: &mut State)
MoveLoc[14](loc10: &mut vector<Fill>)
CopyLoc[3](Arg3: &TxContext)
Call process_fills(&mut State, &mut vector<Fill>, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::balance_manager_id(&OrderInfo): ID
MoveLoc[3](Arg3: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::balance_manager_id(&OrderInfo): ID
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[9](loc5: &mut Account)
CopyLoc[9](loc5: &mut Account)
FreezeRef
Call account::total_volume(&Account): u128
StLoc[11](loc7: u128)
CopyLoc[9](loc5: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
StLoc[10](loc6: u64)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::executed_quantity(&OrderInfo): u64
LdU64(0)
Gt
BrFalse(55)
B1:
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::cumulative_quote_quantity(&OrderInfo): u64
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::executed_quantity(&OrderInfo): u64
Call math::div(u64, u64): u64
StLoc[4](loc0: u64)
Branch(57)
B2:
LdU64(0)
StLoc[4](loc0: u64)
B3:
MoveLoc[4](loc0: u64)
StLoc[13](loc9: u64)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::order_deep_price(&OrderInfo): OrderDeepPrice
StLoc[5](loc1: OrderDeepPrice)
ImmBorrowLoc[5](loc1: OrderDeepPrice)
CopyLoc[11](loc7: u128)
MoveLoc[11](loc7: u128)
MoveLoc[13](loc9: u64)
CastU128
Call math::mul_u128(u128, u128): u128
Call deep_price::deep_quantity_u128(&OrderDeepPrice, u128, u128): u128
StLoc[12](loc8: u128)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
StLoc[6](loc2: TradeParams)
ImmBorrowLoc[6](loc2: TradeParams)
MoveLoc[10](loc6: u64)
MoveLoc[12](loc8: u128)
Call trade_params::taker_fee_for_user(&TradeParams, u64, u128): u64
StLoc[20](loc16: u64)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
StLoc[7](loc3: TradeParams)
ImmBorrowLoc[7](loc3: TradeParams)
Call trade_params::maker_fee(&TradeParams): u64
StLoc[15](loc11: u64)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::order_inserted(&OrderInfo): bool
BrFalse(114)
B4:
CopyLoc[9](loc5: &mut Account)
FreezeRef
Call account::open_orders(&Account): VecSet<u128>
StLoc[8](loc4: VecSet<u128>)
ImmBorrowLoc[8](loc4: VecSet<u128>)
Call vec_set::size<u128>(&VecSet<u128>): u64
Call constants::max_open_orders(): u64
Lt
BrFalse(101)
B5:
Branch(109)
B6:
MoveLoc[0](Arg0: &mut State)
Pop
MoveLoc[1](Arg1: &mut OrderInfo)
Pop
MoveLoc[9](loc5: &mut Account)
Pop
LdConst[1](u64: 2)
Abort
B7:
CopyLoc[9](loc5: &mut Account)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::order_id(&OrderInfo): u128
Call account::add_order(&mut Account, u128)
B8:
CopyLoc[9](loc5: &mut Account)
CopyLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::executed_quantity(&OrderInfo): u64
Call account::add_taker_volume(&mut Account, u64)
CopyLoc[1](Arg1: &mut OrderInfo)
MoveLoc[20](loc16: u64)
MoveLoc[15](loc11: u64)
Call order_info::calculate_partial_fill_balances(&mut OrderInfo, u64, u64): Balances * Balances
StLoc[18](loc14: Balances)
StLoc[19](loc15: Balances)
MoveLoc[9](loc5: &mut Account)
Call account::settle(&mut Account): Balances * Balances
StLoc[16](loc12: Balances)
StLoc[17](loc13: Balances)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
MoveLoc[1](Arg1: &mut OrderInfo)
FreezeRef
Call order_info::paid_fees_balances(&OrderInfo): Balances
Call history::add_total_fees_collected(&mut History, Balances)
MutBorrowLoc[19](loc15: Balances)
MoveLoc[17](loc13: Balances)
Call balances::add_balances(&mut Balances, Balances)
MutBorrowLoc[18](loc14: Balances)
MoveLoc[16](loc12: Balances)
Call balances::add_balances(&mut Balances, Balances)
MoveLoc[19](loc15: Balances)
MoveLoc[18](loc14: Balances)
Ret
}
public(friend) withdraw_settled_amounts(Arg0: &mut State, Arg1: ID): Balances * Balances {
L2:	loc0: Balances
L3:	loc1: Balances
B0:
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[1](Arg1: ID)
Call table::contains<ID, Account>(&Table<ID, Account>, ID): bool
BrFalse(13)
B1:
MoveLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[1](Arg1: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
Call account::settle(&mut Account): Balances * Balances
StLoc[3](loc1: Balances)
StLoc[2](loc0: Balances)
Branch(19)
B2:
MoveLoc[0](Arg0: &mut State)
Pop
Call balances::empty(): Balances
Call balances::empty(): Balances
StLoc[3](loc1: Balances)
StLoc[2](loc0: Balances)
B3:
MoveLoc[2](loc0: Balances)
MoveLoc[3](loc1: Balances)
Ret
}
public(friend) process_cancel(Arg0: &mut State, Arg1: &mut Order, Arg2: ID, Arg3: ID, Arg4: &TxContext): Balances * Balances {
L5:	loc0: &mut Account
L6:	loc1: Balances
L7:	loc2: u64
L8:	loc3: u64
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[4](Arg4: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
MoveLoc[3](Arg3: ID)
CopyLoc[4](Arg4: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[2](Arg2: ID)
MoveLoc[4](Arg4: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[1](Arg1: &mut Order)
Call order::set_canceled(&mut Order)
CopyLoc[1](Arg1: &mut Order)
FreezeRef
Call order::epoch(&Order): u64
StLoc[7](loc2: u64)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[1](State.history: History)
MoveLoc[7](loc2: u64)
Call history::historic_maker_fee(&History, u64): u64
StLoc[8](loc3: u64)
CopyLoc[1](Arg1: &mut Order)
FreezeRef
MoveLoc[8](loc3: u64)
Call option::none<u64>(): Option<u64>
Call order::calculate_cancel_refund(&Order, u64, Option<u64>): Balances
StLoc[6](loc1: Balances)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[2](Arg2: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[5](loc0: &mut Account)
CopyLoc[5](loc0: &mut Account)
MoveLoc[1](Arg1: &mut Order)
FreezeRef
Call order::order_id(&Order): u128
Call account::remove_order(&mut Account, u128)
CopyLoc[5](loc0: &mut Account)
MoveLoc[6](loc1: Balances)
Call account::add_settled_balances(&mut Account, Balances)
MoveLoc[5](loc0: &mut Account)
Call account::settle(&mut Account): Balances * Balances
Ret
}
public(friend) process_modify(Arg0: &mut State, Arg1: ID, Arg2: u64, Arg3: &Order, Arg4: ID, Arg5: &TxContext): Balances * Balances {
L6:	loc0: Balances
L7:	loc1: u64
L8:	loc2: u64
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[5](Arg5: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
MoveLoc[4](Arg4: ID)
CopyLoc[5](Arg5: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[1](Arg1: ID)
MoveLoc[5](Arg5: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[3](Arg3: &Order)
Call order::epoch(&Order): u64
StLoc[7](loc1: u64)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[1](State.history: History)
MoveLoc[7](loc1: u64)
Call history::historic_maker_fee(&History, u64): u64
StLoc[8](loc2: u64)
MoveLoc[3](Arg3: &Order)
MoveLoc[8](loc2: u64)
MoveLoc[2](Arg2: u64)
Call option::some<u64>(u64): Option<u64>
Call order::calculate_cancel_refund(&Order, u64, Option<u64>): Balances
StLoc[6](loc0: Balances)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[1](Arg1: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
MoveLoc[6](loc0: Balances)
Call account::add_settled_balances(&mut Account, Balances)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[1](Arg1: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
Call account::settle(&mut Account): Balances * Balances
Ret
}
public(friend) process_stake(Arg0: &mut State, Arg1: ID, Arg2: ID, Arg3: u64, Arg4: &TxContext): Balances * Balances {
L5:	loc0: u64
L6:	loc1: u64
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[4](Arg4: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
CopyLoc[1](Arg1: ID)
CopyLoc[4](Arg4: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[2](Arg2: ID)
CopyLoc[4](Arg4: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[2](Arg2: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
CopyLoc[3](Arg3: u64)
Call account::add_stake(&mut Account, u64): u64 * u64
StLoc[5](loc0: u64)
StLoc[6](loc1: u64)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
MoveLoc[6](loc1: u64)
MoveLoc[5](loc0: u64)
Call governance::adjust_voting_power(&mut Governance, u64, u64)
MoveLoc[1](Arg1: ID)
CopyLoc[2](Arg2: ID)
MoveLoc[4](Arg4: &TxContext)
Call tx_context::epoch(&TxContext): u64
MoveLoc[3](Arg3: u64)
LdTrue
Pack[1](StakeEvent)
Call event::emit<StakeEvent>(StakeEvent)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[2](Arg2: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
Call account::settle(&mut Account): Balances * Balances
Ret
}
public(friend) process_unstake(Arg0: &mut State, Arg1: ID, Arg2: ID, Arg3: &TxContext): Balances * Balances {
L4:	loc0: &mut Account
L5:	loc1: u64
L6:	loc2: u64
L7:	loc3: Option<ID>
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[3](Arg3: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
CopyLoc[1](Arg1: ID)
CopyLoc[3](Arg3: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[2](Arg2: ID)
CopyLoc[3](Arg3: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[2](Arg2: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[4](loc0: &mut Account)
CopyLoc[4](loc0: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
StLoc[5](loc1: u64)
CopyLoc[4](loc0: &mut Account)
FreezeRef
Call account::inactive_stake(&Account): u64
StLoc[6](loc2: u64)
CopyLoc[4](loc0: &mut Account)
FreezeRef
Call account::voted_proposal(&Account): Option<ID>
StLoc[7](loc3: Option<ID>)
CopyLoc[4](loc0: &mut Account)
Call account::remove_stake(&mut Account)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[5](loc1: u64)
CopyLoc[6](loc2: u64)
Add
LdU64(0)
Call governance::adjust_voting_power(&mut Governance, u64, u64)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
MoveLoc[7](loc3: Option<ID>)
Call option::none<ID>(): Option<ID>
CopyLoc[5](loc1: u64)
Call governance::adjust_vote(&mut Governance, Option<ID>, Option<ID>, u64)
MoveLoc[1](Arg1: ID)
MoveLoc[2](Arg2: ID)
MoveLoc[3](Arg3: &TxContext)
Call tx_context::epoch(&TxContext): u64
MoveLoc[5](loc1: u64)
MoveLoc[6](loc2: u64)
Add
LdFalse
Pack[1](StakeEvent)
Call event::emit<StakeEvent>(StakeEvent)
MoveLoc[4](loc0: &mut Account)
Call account::settle(&mut Account): Balances * Balances
Ret
}
public(friend) process_proposal(Arg0: &mut State, Arg1: ID, Arg2: ID, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &TxContext) {
L7:	loc0: &mut Account
L8:	loc1: bool
L9:	loc2: u64
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[6](Arg6: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
CopyLoc[1](Arg1: ID)
CopyLoc[6](Arg6: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[2](Arg2: ID)
CopyLoc[6](Arg6: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[2](Arg2: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[7](loc0: &mut Account)
CopyLoc[7](loc0: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
StLoc[9](loc2: u64)
CopyLoc[7](loc0: &mut Account)
FreezeRef
Call account::created_proposal(&Account): bool
StLoc[8](loc1: bool)
CopyLoc[9](loc2: u64)
LdU64(0)
Gt
BrFalse(34)
B1:
Branch(42)
B2:
MoveLoc[0](Arg0: &mut State)
Pop
MoveLoc[6](Arg6: &TxContext)
Pop
MoveLoc[7](loc0: &mut Account)
Pop
LdConst[0](u64: 1)
Abort
B3:
MoveLoc[8](loc1: bool)
Not
BrFalse(46)
B4:
Branch(54)
B5:
MoveLoc[0](Arg0: &mut State)
Pop
MoveLoc[6](Arg6: &TxContext)
Pop
MoveLoc[7](loc0: &mut Account)
Pop
LdConst[2](u64: 3)
Abort
B6:
MoveLoc[7](loc0: &mut Account)
LdTrue
Call account::set_created_proposal(&mut Account, bool)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[3](Arg3: u64)
CopyLoc[4](Arg4: u64)
CopyLoc[5](Arg5: u64)
MoveLoc[9](loc2: u64)
CopyLoc[2](Arg2: ID)
Call governance::add_proposal(&mut Governance, u64, u64, u64, u64, ID)
MoveLoc[0](Arg0: &mut State)
CopyLoc[1](Arg1: ID)
CopyLoc[2](Arg2: ID)
CopyLoc[2](Arg2: ID)
CopyLoc[6](Arg6: &TxContext)
Call process_vote(&mut State, ID, ID, ID, &TxContext)
MoveLoc[1](Arg1: ID)
MoveLoc[2](Arg2: ID)
MoveLoc[6](Arg6: &TxContext)
Call tx_context::epoch(&TxContext): u64
MoveLoc[3](Arg3: u64)
MoveLoc[4](Arg4: u64)
MoveLoc[5](Arg5: u64)
Pack[2](ProposalEvent)
Call event::emit<ProposalEvent>(ProposalEvent)
Ret
}
public(friend) process_vote(Arg0: &mut State, Arg1: ID, Arg2: ID, Arg3: ID, Arg4: &TxContext) {
L5:	loc0: &mut Account
L6:	loc1: Option<ID>
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[4](Arg4: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
CopyLoc[1](Arg1: ID)
CopyLoc[4](Arg4: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[2](Arg2: ID)
CopyLoc[4](Arg4: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[2](Arg2: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[5](loc0: &mut Account)
CopyLoc[5](loc0: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
LdU64(0)
Gt
BrFalse(28)
B1:
Branch(36)
B2:
MoveLoc[0](Arg0: &mut State)
Pop
MoveLoc[4](Arg4: &TxContext)
Pop
MoveLoc[5](loc0: &mut Account)
Pop
LdConst[0](u64: 1)
Abort
B3:
CopyLoc[5](loc0: &mut Account)
CopyLoc[3](Arg3: ID)
Call option::some<ID>(ID): Option<ID>
Call account::set_voted_proposal(&mut Account, Option<ID>): Option<ID>
StLoc[6](loc1: Option<ID>)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[6](loc1: Option<ID>)
CopyLoc[3](Arg3: ID)
Call option::some<ID>(ID): Option<ID>
CopyLoc[5](loc0: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
Call governance::adjust_vote(&mut Governance, Option<ID>, Option<ID>, u64)
MoveLoc[1](Arg1: ID)
MoveLoc[2](Arg2: ID)
MoveLoc[4](Arg4: &TxContext)
Call tx_context::epoch(&TxContext): u64
MoveLoc[6](loc1: Option<ID>)
MoveLoc[3](Arg3: ID)
MoveLoc[5](loc0: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
Pack[3](VoteEvent)
Call event::emit<VoteEvent>(VoteEvent)
Ret
}
public(friend) process_claim_rebates<Ty0, Ty1>(Arg0: &mut State, Arg1: ID, Arg2: &BalanceManager, Arg3: &TxContext): Balances * Balances {
L4:	loc0: &mut Account
L5:	loc1: ID
L6:	loc2: Balances
B0:
CopyLoc[2](Arg2: &BalanceManager)
Call balance_manager::id(&BalanceManager): ID
StLoc[5](loc1: ID)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
CopyLoc[3](Arg3: &TxContext)
Call governance::update(&mut Governance, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[0](State.governance: Governance)
Call governance::trade_params(&Governance): TradeParams
CopyLoc[1](Arg1: ID)
CopyLoc[3](Arg3: &TxContext)
Call history::update(&mut History, TradeParams, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
CopyLoc[5](loc1: ID)
CopyLoc[3](Arg3: &TxContext)
Call update_account(&mut State, ID, &TxContext)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[5](loc1: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[4](loc0: &mut Account)
CopyLoc[4](loc0: &mut Account)
Call account::claim_rebates(&mut Account): Balances
StLoc[6](loc2: Balances)
MoveLoc[1](Arg1: ID)
MoveLoc[5](loc1: ID)
MoveLoc[3](Arg3: &TxContext)
Call tx_context::epoch(&TxContext): u64
CopyLoc[6](loc2: Balances)
Pack[4](RebateEventV2)
Call event::emit<RebateEventV2>(RebateEventV2)
CopyLoc[2](Arg2: &BalanceManager)
Call type_name::get<DEEP>(): TypeName
ImmBorrowLoc[6](loc2: Balances)
Call balances::deep(&Balances): u64
LdTrue
Call balance_manager::emit_balance_event(&BalanceManager, TypeName, u64, bool)
CopyLoc[2](Arg2: &BalanceManager)
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[6](loc2: Balances)
Call balances::base(&Balances): u64
LdTrue
Call balance_manager::emit_balance_event(&BalanceManager, TypeName, u64, bool)
MoveLoc[2](Arg2: &BalanceManager)
Call type_name::get<Ty1>(): TypeName
ImmBorrowLoc[6](loc2: Balances)
Call balances::quote(&Balances): u64
LdTrue
Call balance_manager::emit_balance_event(&BalanceManager, TypeName, u64, bool)
MoveLoc[4](loc0: &mut Account)
Call account::settle(&mut Account): Balances * Balances
Ret
}
public(friend) governance(Arg0: &State): &Governance {
B0:
MoveLoc[0](Arg0: &State)
ImmBorrowField[0](State.governance: Governance)
Ret
}
public(friend) governance_mut(Arg0: &mut State, Arg1: &TxContext): &mut Governance {
B0:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
MoveLoc[1](Arg1: &TxContext)
Call governance::update(&mut Governance, &TxContext)
MoveLoc[0](Arg0: &mut State)
MutBorrowField[0](State.governance: Governance)
Ret
}
public(friend) account_exists(Arg0: &State, Arg1: ID): bool {
B0:
MoveLoc[0](Arg0: &State)
ImmBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[1](Arg1: ID)
Call table::contains<ID, Account>(&Table<ID, Account>, ID): bool
Ret
}
public(friend) account(Arg0: &State, Arg1: ID): &Account {
B0:
MoveLoc[0](Arg0: &State)
ImmBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[1](Arg1: ID)
Call table::borrow<ID, Account>(&Table<ID, Account>, ID): &Account
Ret
}
public(friend) history_mut(Arg0: &mut State): &mut History {
B0:
MoveLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
Ret
}
public(friend) history(Arg0: &State): &History {
B0:
MoveLoc[0](Arg0: &State)
ImmBorrowField[1](State.history: History)
Ret
}
process_fills(Arg0: &mut State, Arg1: &mut vector<Fill>, Arg2: &TxContext) {
L3:	loc0: OrderDeepPrice
L4:	loc1: &mut Account
L5:	loc2: u64
L6:	loc3: Balances
L7:	loc4: &mut Fill
L8:	loc5: u64
L9:	loc6: u64
L10:	loc7: ID
L11:	loc8: bool
L12:	loc9: u64
L13:	loc10: u64
B0:
LdU64(0)
StLoc[9](loc6: u64)
CopyLoc[1](Arg1: &mut vector<Fill>)
FreezeRef
VecLen(92)
StLoc[12](loc9: u64)
B1:
CopyLoc[9](loc6: u64)
CopyLoc[12](loc9: u64)
Lt
BrFalse(95)
B2:
Branch(11)
B3:
CopyLoc[1](Arg1: &mut vector<Fill>)
CopyLoc[9](loc6: u64)
VecMutBorrow(92)
StLoc[7](loc4: &mut Fill)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::balance_manager_id(&Fill): ID
StLoc[10](loc7: ID)
CopyLoc[0](Arg0: &mut State)
CopyLoc[10](loc7: ID)
CopyLoc[2](Arg2: &TxContext)
Call update_account(&mut State, ID, &TxContext)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[10](loc7: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[4](loc1: &mut Account)
CopyLoc[4](loc1: &mut Account)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call account::process_maker_fill(&mut Account, &Fill)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::base_quantity(&Fill): u64
StLoc[5](loc2: u64)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::quote_quantity(&Fill): u64
StLoc[13](loc10: u64)
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[1](State.history: History)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::maker_epoch(&Fill): u64
Call history::historic_maker_fee(&History, u64): u64
StLoc[8](loc5: u64)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::taker_is_bid(&Fill): bool
Not
StLoc[11](loc8: bool)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::maker_deep_price(&Fill): OrderDeepPrice
StLoc[3](loc0: OrderDeepPrice)
ImmBorrowLoc[3](loc0: OrderDeepPrice)
CopyLoc[5](loc2: u64)
MoveLoc[13](loc10: u64)
MoveLoc[11](loc8: bool)
Call deep_price::fee_quantity(&OrderDeepPrice, u64, u64, bool): Balances
StLoc[6](loc3: Balances)
MutBorrowLoc[6](loc3: Balances)
MoveLoc[8](loc5: u64)
Call balances::mul(&mut Balances, u64)
CopyLoc[7](loc4: &mut Fill)
FreezeRef
Call fill::expired(&Fill): bool
Not
BrFalse(85)
B4:
MoveLoc[7](loc4: &mut Fill)
ImmBorrowLoc[6](loc3: Balances)
Call fill::set_fill_maker_fee(&mut Fill, &Balances)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
MoveLoc[5](loc2: u64)
MoveLoc[4](loc1: &mut Account)
FreezeRef
Call account::active_stake(&Account): u64
Call history::add_volume(&mut History, u64, u64)
CopyLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
MoveLoc[6](loc3: Balances)
Call history::add_total_fees_collected(&mut History, Balances)
Branch(90)
B5:
MoveLoc[7](loc4: &mut Fill)
Pop
MoveLoc[4](loc1: &mut Account)
MoveLoc[6](loc3: Balances)
Call account::add_settled_balances(&mut Account, Balances)
B6:
MoveLoc[9](loc6: u64)
LdU64(1)
Add
StLoc[9](loc6: u64)
Branch(6)
B7:
MoveLoc[0](Arg0: &mut State)
Pop
MoveLoc[1](Arg1: &mut vector<Fill>)
Pop
MoveLoc[2](Arg2: &TxContext)
Pop
Ret
}
update_account(Arg0: &mut State, Arg1: ID, Arg2: &TxContext) {
L3:	loc0: bool
L4:	loc1: &mut Account
L5:	loc2: u64
L6:	loc3: u128
L7:	loc4: u64
L8:	loc5: Balances
B0:
CopyLoc[0](Arg0: &mut State)
ImmBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[1](Arg1: ID)
Call table::contains<ID, Account>(&Table<ID, Account>, ID): bool
Not
BrFalse(12)
B1:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
CopyLoc[1](Arg1: ID)
CopyLoc[2](Arg2: &TxContext)
Call account::empty(&TxContext): Account
Call table::add<ID, Account>(&mut Table<ID, Account>, ID, Account)
B2:
CopyLoc[0](Arg0: &mut State)
MutBorrowField[2](State.accounts: Table<ID, Account>)
MoveLoc[1](Arg1: ID)
Call table::borrow_mut<ID, Account>(&mut Table<ID, Account>, ID): &mut Account
StLoc[4](loc1: &mut Account)
CopyLoc[4](loc1: &mut Account)
MoveLoc[2](Arg2: &TxContext)
Call account::update(&mut Account, &TxContext): u64 * u128 * u64
StLoc[5](loc2: u64)
StLoc[6](loc3: u128)
StLoc[7](loc4: u64)
CopyLoc[7](loc4: u64)
LdU64(0)
Gt
BrFalse(39)
B3:
CopyLoc[6](loc3: u128)
LdU128(0)
Gt
BrFalse(36)
B4:
CopyLoc[5](loc2: u64)
LdU64(0)
Gt
StLoc[3](loc0: bool)
Branch(41)
B5:
LdFalse
StLoc[3](loc0: bool)
Branch(41)
B6:
LdFalse
StLoc[3](loc0: bool)
B7:
MoveLoc[3](loc0: bool)
BrFalse(54)
B8:
MoveLoc[0](Arg0: &mut State)
MutBorrowField[1](State.history: History)
MoveLoc[7](loc4: u64)
MoveLoc[6](loc3: u128)
MoveLoc[5](loc2: u64)
Call history::calculate_rebate_amount(&mut History, u64, u128, u64): Balances
StLoc[8](loc5: Balances)
MoveLoc[4](loc1: &mut Account)
MoveLoc[8](loc5: Balances)
Call account::add_rebates(&mut Account, Balances)
Branch(58)
B9:
MoveLoc[0](Arg0: &mut State)
Pop
MoveLoc[4](loc1: &mut Account)
Pop
B10:
Ret
}
Constants [
=> u64: 1
=> u64: 2
=> u64: 3
]
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/trade_params.mvb87 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.trade_params {
struct TradeParams has copy, drop, store {
	taker_fee: u64,
	maker_fee: u64,
	stake_required: u64
}
public(friend) new(Arg0: u64, Arg1: u64, Arg2: u64): TradeParams {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u64)
	2: MoveLoc[2](Arg2: u64)
	3: Pack[0](TradeParams)
	4: Ret
}
public(friend) maker_fee(Arg0: &TradeParams): u64 {
B0:
	0: MoveLoc[0](Arg0: &TradeParams)
	1: ImmBorrowField[0](TradeParams.maker_fee: u64)
	2: ReadRef
	3: Ret
}
public(friend) taker_fee(Arg0: &TradeParams): u64 {
B0:
	0: MoveLoc[0](Arg0: &TradeParams)
	1: ImmBorrowField[1](TradeParams.taker_fee: u64)
	2: ReadRef
	3: Ret
}
public(friend) taker_fee_for_user(Arg0: &TradeParams, Arg1: u64, Arg2: u128): u64 {
L3:	loc0: bool
L4:	loc1: u64
B0:
	0: MoveLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &TradeParams)
	2: ImmBorrowField[2](TradeParams.stake_required: u64)
	3: ReadRef
	4: Ge
	5: BrFalse(14)
B1:
	6: MoveLoc[2](Arg2: u128)
	7: CopyLoc[0](Arg0: &TradeParams)
	8: ImmBorrowField[2](TradeParams.stake_required: u64)
	9: ReadRef
	10: CastU128
	11: Ge
	12: StLoc[3](loc0: bool)
	13: Branch(16)
B2:
	14: LdFalse
	15: StLoc[3](loc0: bool)
B3:
	16: MoveLoc[3](loc0: bool)
	17: BrFalse(25)
B4:
	18: MoveLoc[0](Arg0: &TradeParams)
	19: ImmBorrowField[1](TradeParams.taker_fee: u64)
	20: ReadRef
	21: LdU64(2)
	22: Div
	23: StLoc[4](loc1: u64)
	24: Branch(29)
B5:
	25: MoveLoc[0](Arg0: &TradeParams)
	26: ImmBorrowField[1](TradeParams.taker_fee: u64)
	27: ReadRef
	28: StLoc[4](loc1: u64)
B6:
	29: MoveLoc[4](loc1: u64)
	30: Ret
}
public(friend) stake_required(Arg0: &TradeParams): u64 {
B0:
	0: MoveLoc[0](Arg0: &TradeParams)
	1: ImmBorrowField[2](TradeParams.stake_required: u64)
	2: ReadRef
	3: Ret
}
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/utils.mvb135 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.utils {
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
public(friend) pop_until<Ty0>(Arg0: &mut vector<Ty0>, Arg1: u64): vector<Ty0> {
L2:	loc0: vector<Ty0>
B0:
VecPack(4, 0)
StLoc[2](loc0: vector<Ty0>)
B1:
CopyLoc[0](Arg0: &mut vector<Ty0>)
FreezeRef
VecLen(4)
CopyLoc[1](Arg1: u64)
Gt
BrFalse(14)
B2:
Branch(9)
B3:
MutBorrowLoc[2](loc0: vector<Ty0>)
CopyLoc[0](Arg0: &mut vector<Ty0>)
VecPopBack(4)
VecPushBack(4)
Branch(2)
B4:
MoveLoc[0](Arg0: &mut vector<Ty0>)
Pop
MutBorrowLoc[2](loc0: vector<Ty0>)
Call vector::reverse<Ty0>(&mut vector<Ty0>)
MoveLoc[2](loc0: vector<Ty0>)
Ret
}
public(friend) pop_n<Ty0>(Arg0: &mut vector<Ty0>, Arg1: u64): vector<Ty0> {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: vector<Ty0>
L5:	loc3: u64
B0:
VecPack(4, 0)
StLoc[4](loc2: vector<Ty0>)
MoveLoc[1](Arg1: u64)
StLoc[2](loc0: u64)
LdU64(0)
StLoc[3](loc1: u64)
MoveLoc[2](loc0: u64)
StLoc[5](loc3: u64)
B1:
CopyLoc[3](loc1: u64)
CopyLoc[5](loc3: u64)
Lt
BrFalse(23)
B2:
CopyLoc[3](loc1: u64)
Pop
MutBorrowLoc[4](loc2: vector<Ty0>)
CopyLoc[0](Arg0: &mut vector<Ty0>)
VecPopBack(4)
VecPushBack(4)
MoveLoc[3](loc1: u64)
LdU64(1)
Add
StLoc[3](loc1: u64)
Branch(8)
B3:
MoveLoc[0](Arg0: &mut vector<Ty0>)
Pop
MutBorrowLoc[4](loc2: vector<Ty0>)
Call vector::reverse<Ty0>(&mut vector<Ty0>)
MoveLoc[4](loc2: vector<Ty0>)
Ret
}
public(friend) encode_order_id(Arg0: bool, Arg1: u64, Arg2: u64): u128 {
L3:	loc0: u128
B0:
MoveLoc[0](Arg0: bool)
BrFalse(11)
B1:
MoveLoc[1](Arg1: u64)
CastU128
LdU8(64)
Shl
MoveLoc[2](Arg2: u64)
CastU128
Add
StLoc[3](loc0: u128)
Branch(21)
B2:
LdU128(170141183460469231731687303715884105728)
MoveLoc[1](Arg1: u64)
CastU128
LdU8(64)
Shl
Add
MoveLoc[2](Arg2: u64)
CastU128
Add
StLoc[3](loc0: u128)
B3:
MoveLoc[3](loc0: u128)
Ret
}
public(friend) decode_order_id(Arg0: u128): bool * u64 * u64 {
L1:	loc0: bool
L2:	loc1: u64
L3:	loc2: u64
B0:
CopyLoc[0](Arg0: u128)
LdU8(127)
Shr
LdU128(0)
Eq
StLoc[1](loc0: bool)
CopyLoc[0](Arg0: u128)
LdU8(64)
Shr
CastU64
LdU64(9223372036854775807)
BitAnd
StLoc[3](loc2: u64)
MoveLoc[0](Arg0: u128)
LdU128(18446744073709551615)
BitAnd
CastU64
StLoc[2](loc1: u64)
MoveLoc[1](loc0: bool)
MoveLoc[3](loc2: u64)
MoveLoc[2](loc1: u64)
Ret
}
}

0xcaf6ba059d539a97646d47f0b9ddf843e138d215e2a12ca1f4585d386f7aec3a/bytecode/vault.mvb463 lines

// Move bytecode v6
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.vault {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balance_manager;
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balances;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use deeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep;
struct Vault<phantom Ty0, phantom Ty1> has store {
	base_balance: Balance<Ty0>,
	quote_balance: Balance<Ty1>,
	deep_balance: Balance<DEEP>
}
struct FlashLoan {
	pool_id: ID,
	borrow_quantity: u64,
	type_name: TypeName
}
struct FlashLoanBorrowed has copy, drop {
	pool_id: ID,
	borrow_quantity: u64,
	type_name: TypeName
}
public(friend) balances<Ty0, Ty1>(Arg0: &Vault<Ty0, Ty1>): u64 * u64 * u64 {
B0:
CopyLoc[0](Arg0: &Vault<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](Vault.base_balance: Balance<Ty0>)
Call balance::value<Ty0>(&Balance<Ty0>): u64
CopyLoc[0](Arg0: &Vault<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](Vault.quote_balance: Balance<Ty1>)
Call balance::value<Ty1>(&Balance<Ty1>): u64
MoveLoc[0](Arg0: &Vault<Ty0, Ty1>)
ImmBorrowFieldGeneric[2](Vault.deep_balance: Balance<DEEP>)
Call balance::value<DEEP>(&Balance<DEEP>): u64
Ret
}
public(friend) empty<Ty0, Ty1>(): Vault<Ty0, Ty1> {
B0:
Call balance::zero<Ty0>(): Balance<Ty0>
Call balance::zero<Ty1>(): Balance<Ty1>
Call balance::zero<DEEP>(): Balance<DEEP>
PackGeneric[0](Vault<Ty0, Ty1>)
Ret
}
public(friend) settle_balance_manager<Ty0, Ty1>(Arg0: &mut Vault<Ty0, Ty1>, Arg1: Balances, Arg2: Balances, Arg3: &mut BalanceManager, Arg4: &TradeProof) {
L5:	loc0: Balance<Ty0>
L6:	loc1: Balance<Ty1>
L7:	loc2: Balance<DEEP>
L8:	loc3: Balance<Ty0>
L9:	loc4: Balance<Ty1>
L10:	loc5: Balance<DEEP>
B0:
CopyLoc[3](Arg3: &mut BalanceManager)
FreezeRef
CopyLoc[4](Arg4: &TradeProof)
Call balance_manager::validate_proof(&BalanceManager, &TradeProof)
ImmBorrowLoc[1](Arg1: Balances)
Call balances::base(&Balances): u64
ImmBorrowLoc[2](Arg2: Balances)
Call balances::base(&Balances): u64
Gt
BrFalse(23)
B1:
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[0](Vault.base_balance: Balance<Ty0>)
ImmBorrowLoc[1](Arg1: Balances)
Call balances::base(&Balances): u64
ImmBorrowLoc[2](Arg2: Balances)
Call balances::base(&Balances): u64
Sub
Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
StLoc[5](loc0: Balance<Ty0>)
CopyLoc[3](Arg3: &mut BalanceManager)
CopyLoc[4](Arg4: &TradeProof)
MoveLoc[5](loc0: Balance<Ty0>)
Call balance_manager::deposit_with_proof<Ty0>(&mut BalanceManager, &TradeProof, Balance<Ty0>)
B2:
ImmBorrowLoc[1](Arg1: Balances)
Call balances::quote(&Balances): u64
ImmBorrowLoc[2](Arg2: Balances)
Call balances::quote(&Balances): u64
Gt
BrFalse(42)
B3:
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[1](Vault.quote_balance: Balance<Ty1>)
ImmBorrowLoc[1](Arg1: Balances)
Call balances::quote(&Balances): u64
ImmBorrowLoc[2](Arg2: Balances)
Call balances::quote(&Balances): u64
Sub
Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
StLoc[6](loc1: Balance<Ty1>)
CopyLoc[3](Arg3: &mut BalanceManager)
CopyLoc[4](Arg4: &TradeProof)
MoveLoc[6](loc1: Balance<Ty1>)
Call balance_manager::deposit_with_proof<Ty1>(&mut BalanceManager, &TradeProof, Balance<Ty1>)
B4:
ImmBorrowLoc[1](Arg1: Balances)
Call balances::deep(&Balances): u64
ImmBorrowLoc[2](Arg2: Balances)
Call balances::deep(&Balances): u64
Gt
BrFalse(61)
B5:
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[2](Vault.deep_balance: Balance<DEEP>)
ImmBorrowLoc[1](Arg1: Balances)
Call balances::deep(&Balances): u64
ImmBorrowLoc[2](Arg2: Balances)
Call balances::deep(&Balances): u64
Sub
Call balance::split<DEEP>(&mut Balance<DEEP>, u64): Balance<DEEP>
StLoc[7](loc2: Balance<DEEP>)
CopyLoc[3](Arg3: &mut BalanceManager)
CopyLoc[4](Arg4: &TradeProof)
MoveLoc[7](loc2: Balance<DEEP>)
Call balance_manager::deposit_with_proof<DEEP>(&mut BalanceManager, &TradeProof, Balance<DEEP>)
B6:
ImmBorrowLoc[2](Arg2: Balances)
Call balances::base(&Balances): u64
ImmBorrowLoc[1](Arg1: Balances)
Call balances::base(&Balances): u64
Gt
BrFalse(82)
B7:
CopyLoc[3](Arg3: &mut BalanceManager)
CopyLoc[4](Arg4: &TradeProof)
ImmBorrowLoc[2](Arg2: Balances)
Call balances::base(&Balances): u64
ImmBorrowLoc[1](Arg1: Balances)
Call balances::base(&Balances): u64
Sub
LdFalse
Call balance_manager::withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
StLoc[8](loc3: Balance<Ty0>)
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[0](Vault.base_balance: Balance<Ty0>)
MoveLoc[8](loc3: Balance<Ty0>)
Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
Pop
B8:
ImmBorrowLoc[2](Arg2: Balances)
Call balances::quote(&Balances): u64
ImmBorrowLoc[1](Arg1: Balances)
Call balances::quote(&Balances): u64
Gt
BrFalse(103)
B9:
CopyLoc[3](Arg3: &mut BalanceManager)
CopyLoc[4](Arg4: &TradeProof)
ImmBorrowLoc[2](Arg2: Balances)
Call balances::quote(&Balances): u64
ImmBorrowLoc[1](Arg1: Balances)
Call balances::quote(&Balances): u64
Sub
LdFalse
Call balance_manager::withdraw_with_proof<Ty1>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty1>
StLoc[9](loc4: Balance<Ty1>)
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[1](Vault.quote_balance: Balance<Ty1>)
MoveLoc[9](loc4: Balance<Ty1>)
Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
Pop
B10:
ImmBorrowLoc[2](Arg2: Balances)
Call balances::deep(&Balances): u64
ImmBorrowLoc[1](Arg1: Balances)
Call balances::deep(&Balances): u64
Gt
BrFalse(125)
B11:
MoveLoc[3](Arg3: &mut BalanceManager)
MoveLoc[4](Arg4: &TradeProof)
ImmBorrowLoc[2](Arg2: Balances)
Call balances::deep(&Balances): u64
ImmBorrowLoc[1](Arg1: Balances)
Call balances::deep(&Balances): u64
Sub
LdFalse
Call balance_manager::withdraw_with_proof<DEEP>(&mut BalanceManager, &TradeProof, u64, bool): Balance<DEEP>
StLoc[10](loc5: Balance<DEEP>)
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[2](Vault.deep_balance: Balance<DEEP>)
MoveLoc[10](loc5: Balance<DEEP>)
Call balance::join<DEEP>(&mut Balance<DEEP>, Balance<DEEP>): u64
Pop
Branch(131)
B12:
MoveLoc[4](Arg4: &TradeProof)
Pop
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &mut BalanceManager)
Pop
B13:
Ret
}
public(friend) withdraw_deep_to_burn<Ty0, Ty1>(Arg0: &mut Vault<Ty0, Ty1>, Arg1: u64): Balance<DEEP> {
B0:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[2](Vault.deep_balance: Balance<DEEP>)
MoveLoc[1](Arg1: u64)
Call balance::split<DEEP>(&mut Balance<DEEP>, u64): Balance<DEEP>
Ret
}
public(friend) borrow_flashloan_base<Ty0, Ty1>(Arg0: &mut Vault<Ty0, Ty1>, Arg1: ID, Arg2: u64, Arg3: &mut TxContext): Coin<Ty0> * FlashLoan {
L4:	loc0: Coin<Ty0>
L5:	loc1: TypeName
L6:	loc2: FlashLoan
B0:
CopyLoc[2](Arg2: u64)
LdU64(0)
Gt
BrFalse(5)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &mut TxContext)
Pop
LdConst[2](u64: 3)
Abort
B3:
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
ImmBorrowFieldGeneric[0](Vault.base_balance: Balance<Ty0>)
Call balance::value<Ty0>(&Balance<Ty0>): u64
CopyLoc[2](Arg2: u64)
Ge
BrFalse(18)
B4:
Branch(24)
B5:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &mut TxContext)
Pop
LdConst[0](u64: 1)
Abort
B6:
Call type_name::get<Ty0>(): TypeName
StLoc[5](loc1: TypeName)
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[0](Vault.base_balance: Balance<Ty0>)
CopyLoc[2](Arg2: u64)
Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
MoveLoc[3](Arg3: &mut TxContext)
Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
StLoc[4](loc0: Coin<Ty0>)
CopyLoc[1](Arg1: ID)
CopyLoc[2](Arg2: u64)
CopyLoc[5](loc1: TypeName)
Pack[1](FlashLoan)
StLoc[6](loc2: FlashLoan)
MoveLoc[1](Arg1: ID)
MoveLoc[2](Arg2: u64)
MoveLoc[5](loc1: TypeName)
Pack[2](FlashLoanBorrowed)
Call event::emit<FlashLoanBorrowed>(FlashLoanBorrowed)
MoveLoc[4](loc0: Coin<Ty0>)
MoveLoc[6](loc2: FlashLoan)
Ret
}
public(friend) borrow_flashloan_quote<Ty0, Ty1>(Arg0: &mut Vault<Ty0, Ty1>, Arg1: ID, Arg2: u64, Arg3: &mut TxContext): Coin<Ty1> * FlashLoan {
L4:	loc0: Coin<Ty1>
L5:	loc1: TypeName
L6:	loc2: FlashLoan
B0:
CopyLoc[2](Arg2: u64)
LdU64(0)
Gt
BrFalse(5)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &mut TxContext)
Pop
LdConst[2](u64: 3)
Abort
B3:
CopyLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
ImmBorrowFieldGeneric[1](Vault.quote_balance: Balance<Ty1>)
Call balance::value<Ty1>(&Balance<Ty1>): u64
CopyLoc[2](Arg2: u64)
Ge
BrFalse(18)
B4:
Branch(24)
B5:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
MoveLoc[3](Arg3: &mut TxContext)
Pop
LdConst[1](u64: 2)
Abort
B6:
Call type_name::get<Ty1>(): TypeName
StLoc[5](loc1: TypeName)
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[1](Vault.quote_balance: Balance<Ty1>)
CopyLoc[2](Arg2: u64)
Call balance::split<Ty1>(&mut Balance<Ty1>, u64): Balance<Ty1>
MoveLoc[3](Arg3: &mut TxContext)
Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
StLoc[4](loc0: Coin<Ty1>)
CopyLoc[1](Arg1: ID)
CopyLoc[2](Arg2: u64)
CopyLoc[5](loc1: TypeName)
Pack[1](FlashLoan)
StLoc[6](loc2: FlashLoan)
MoveLoc[1](Arg1: ID)
MoveLoc[2](Arg2: u64)
MoveLoc[5](loc1: TypeName)
Pack[2](FlashLoanBorrowed)
Call event::emit<FlashLoanBorrowed>(FlashLoanBorrowed)
MoveLoc[4](loc0: Coin<Ty1>)
MoveLoc[6](loc2: FlashLoan)
Ret
}
public(friend) return_flashloan_base<Ty0, Ty1>(Arg0: &mut Vault<Ty0, Ty1>, Arg1: ID, Arg2: Coin<Ty0>, Arg3: FlashLoan) {
B0:
MoveLoc[1](Arg1: ID)
ImmBorrowLoc[3](Arg3: FlashLoan)
ImmBorrowField[3](FlashLoan.pool_id: ID)
ReadRef
Eq
BrFalse(7)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
LdConst[3](u64: 4)
Abort
B3:
Call type_name::get<Ty0>(): TypeName
ImmBorrowLoc[3](Arg3: FlashLoan)
ImmBorrowField[4](FlashLoan.type_name: TypeName)
ReadRef
Eq
BrFalse(18)
B4:
Branch(22)
B5:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
LdConst[4](u64: 5)
Abort
B6:
ImmBorrowLoc[2](Arg2: Coin<Ty0>)
Call coin::value<Ty0>(&Coin<Ty0>): u64
ImmBorrowLoc[3](Arg3: FlashLoan)
ImmBorrowField[5](FlashLoan.borrow_quantity: u64)
ReadRef
Eq
BrFalse(30)
B7:
Branch(34)
B8:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
LdConst[5](u64: 6)
Abort
B9:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[0](Vault.base_balance: Balance<Ty0>)
MoveLoc[2](Arg2: Coin<Ty0>)
Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
Pop
MoveLoc[3](Arg3: FlashLoan)
Unpack[1](FlashLoan)
Pop
Pop
Pop
Ret
}
public(friend) return_flashloan_quote<Ty0, Ty1>(Arg0: &mut Vault<Ty0, Ty1>, Arg1: ID, Arg2: Coin<Ty1>, Arg3: FlashLoan) {
B0:
MoveLoc[1](Arg1: ID)
ImmBorrowLoc[3](Arg3: FlashLoan)
ImmBorrowField[3](FlashLoan.pool_id: ID)
ReadRef
Eq
BrFalse(7)
B1:
Branch(11)
B2:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
LdConst[3](u64: 4)
Abort
B3:
Call type_name::get<Ty1>(): TypeName
ImmBorrowLoc[3](Arg3: FlashLoan)
ImmBorrowField[4](FlashLoan.type_name: TypeName)
ReadRef
Eq
BrFalse(18)
B4:
Branch(22)
B5:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
LdConst[4](u64: 5)
Abort
B6:
ImmBorrowLoc[2](Arg2: Coin<Ty1>)
Call coin::value<Ty1>(&Coin<Ty1>): u64
ImmBorrowLoc[3](Arg3: FlashLoan)
ImmBorrowField[5](FlashLoan.borrow_quantity: u64)
ReadRef
Eq
BrFalse(30)
B7:
Branch(34)
B8:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
Pop
LdConst[5](u64: 6)
Abort
B9:
MoveLoc[0](Arg0: &mut Vault<Ty0, Ty1>)
MutBorrowFieldGeneric[1](Vault.quote_balance: Balance<Ty1>)
MoveLoc[2](Arg2: Coin<Ty1>)
Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
Call balance::join<Ty1>(&mut Balance<Ty1>, Balance<Ty1>): u64
Pop
MoveLoc[3](Arg3: FlashLoan)
Unpack[1](FlashLoan)
Pop
Pop
Pop
Ret
}
Constants [
=> u64: 1
=> u64: 2
=> u64: 3
=> u64: 4
=> u64: 5
=> u64: 6
]
}

This is a circuit, not a contract. It declares no ABI and no storage layout, so there is no interface list and no slot mapping to show. The source above is the whole of what it publishes.

Deployments

This code is deployed at one address. Any other address running the same bytecode would appear here too, already verified.