Package

// Move bytecode v6
module 2.accumulator {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct AccumulatorRoot has key {
	id: UID
}

struct Key<phantom Ty0> has copy, drop, store {
	address: address
}

struct U128 has store {
	value: u128
}

create(Arg0: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[2](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: Call object::safe_accumulator_root_object_id(): UID
	9: Pack[0](AccumulatorRoot)
	10: Call transfer::share_object<AccumulatorRoot>(AccumulatorRoot)
	11: Ret
}

public(friend) accumulator_address<Ty0>(Arg0: address): address {
L1:	loc0: Key<Ty0>
B0:
	0: MoveLoc[0](Arg0: address)
	1: PackGeneric[0](Key<Ty0>)
	2: StLoc[1](loc0: Key<Ty0>)
	3: Call object::safe_accumulator_root_address(): address
	4: MoveLoc[1](loc0: Key<Ty0>)
	5: Call dynamic_field::hash_type_and_key<Key<Ty0>>(address, Key<Ty0>): address
	6: Ret
}

root_has_accumulator<Ty0, Ty1: store>(Arg0: &AccumulatorRoot, Arg1: Key<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &AccumulatorRoot)
	1: ImmBorrowField[0](AccumulatorRoot.id: UID)
	2: MoveLoc[1](Arg1: Key<Ty0>)
	3: Call dynamic_field::exists_with_type<Key<Ty0>, Ty1>(&UID, Key<Ty0>): bool
	4: Ret
}

root_add_accumulator<Ty0, Ty1: store>(Arg0: &mut AccumulatorRoot, Arg1: Key<Ty0>, Arg2: Ty1) {
B0:
	0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	1: MutBorrowField[0](AccumulatorRoot.id: UID)
	2: MoveLoc[1](Arg1: Key<Ty0>)
	3: MoveLoc[2](Arg2: Ty1)
	4: Call dynamic_field::add<Key<Ty0>, Ty1>(&mut UID, Key<Ty0>, Ty1)
	5: Ret
}

root_borrow_accumulator_mut<Ty0, Ty1: store>(Arg0: &mut AccumulatorRoot, Arg1: Key<Ty0>): &mut Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	1: MutBorrowField[0](AccumulatorRoot.id: UID)
	2: MoveLoc[1](Arg1: Key<Ty0>)
	3: Call dynamic_field::borrow_mut<Key<Ty0>, Ty1>(&mut UID, Key<Ty0>): &mut Ty1
	4: Ret
}

root_remove_accumulator<Ty0, Ty1: store>(Arg0: &mut AccumulatorRoot, Arg1: Key<Ty0>): Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	1: MutBorrowField[0](AccumulatorRoot.id: UID)
	2: MoveLoc[1](Arg1: Key<Ty0>)
	3: Call dynamic_field::remove<Key<Ty0>, Ty1>(&mut UID, Key<Ty0>): Ty1
	4: Ret
}

settlement_prologue(Arg0: u64, Arg1: u64, Arg2: u64, Arg3: &TxContext) {
B0:
	0: MoveLoc[3](Arg3: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[2](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: Ret
}

settle_u128<Ty0>(Arg0: &mut AccumulatorRoot, Arg1: address, Arg2: u128, Arg3: u128, Arg4: &TxContext) {
L5:	loc0: Key<Ty0>
L6:	loc1: &mut U128
L7:	loc2: U128
B0:
	0: MoveLoc[4](Arg4: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[2](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: CopyLoc[2](Arg2: u128)
	11: LdU128(0)
	12: Eq
	13: CopyLoc[3](Arg3: u128)
	14: LdU128(0)
	15: Eq
	16: Neq
	17: BrFalse(19)
B4:
	18: Branch(23)
B5:
	19: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	20: Pop
	21: LdConst[1](u64: 1)
	22: Abort
B6:
	23: MoveLoc[1](Arg1: address)
	24: PackGeneric[0](Key<Ty0>)
	25: StLoc[5](loc0: Key<Ty0>)
	26: CopyLoc[0](Arg0: &mut AccumulatorRoot)
	27: FreezeRef
	28: CopyLoc[5](loc0: Key<Ty0>)
	29: Call root_has_accumulator<Ty0, U128>(&AccumulatorRoot, Key<Ty0>): bool
	30: BrFalse(60)
B7:
	31: CopyLoc[0](Arg0: &mut AccumulatorRoot)
	32: CopyLoc[5](loc0: Key<Ty0>)
	33: Call root_borrow_accumulator_mut<Ty0, U128>(&mut AccumulatorRoot, Key<Ty0>): &mut U128
	34: StLoc[6](loc1: &mut U128)
	35: CopyLoc[6](loc1: &mut U128)
	36: ImmBorrowField[1](U128.value: u128)
	37: ReadRef
	38: MoveLoc[2](Arg2: u128)
	39: Add
	40: MoveLoc[3](Arg3: u128)
	41: Sub
	42: CopyLoc[6](loc1: &mut U128)
	43: MutBorrowField[1](U128.value: u128)
	44: WriteRef
	45: MoveLoc[6](loc1: &mut U128)
	46: ImmBorrowField[1](U128.value: u128)
	47: ReadRef
	48: LdU128(0)
	49: Eq
	50: BrFalse(57)
B8:
	51: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	52: MoveLoc[5](loc0: Key<Ty0>)
	53: Call root_remove_accumulator<Ty0, U128>(&mut AccumulatorRoot, Key<Ty0>): U128
	54: Unpack[2](U128)
	55: Pop
	56: Branch(76)
B9:
	57: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	58: Pop
	59: Branch(76)
B10:
	60: MoveLoc[3](Arg3: u128)
	61: LdU128(0)
	62: Eq
	63: BrFalse(65)
B11:
	64: Branch(69)
B12:
	65: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	66: Pop
	67: LdConst[1](u64: 1)
	68: Abort
B13:
	69: MoveLoc[2](Arg2: u128)
	70: Pack[2](U128)
	71: StLoc[7](loc2: U128)
	72: MoveLoc[0](Arg0: &mut AccumulatorRoot)
	73: MoveLoc[5](loc0: Key<Ty0>)
	74: MoveLoc[7](loc2: U128)
	75: Call root_add_accumulator<Ty0, U128>(&mut AccumulatorRoot, Key<Ty0>, U128)
B14:
	76: Ret
}

native public(friend) emit_deposit_event<Ty0>(Arg0: address, Arg1: address, Arg2: u64);

native public(friend) emit_withdraw_event<Ty0>(Arg0: address, Arg1: address, Arg2: u64);

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 2.address {
use 0000000000000000000000000000000000000000000000000000000000000002::hex;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::bcs;
use 0000000000000000000000000000000000000000000000000000000000000001::string;

native public to_u256(Arg0: address): u256;

native public from_u256(Arg0: u256): address;

native public from_bytes(Arg0: vector<u8>): address;

public to_bytes(Arg0: address): vector<u8> {
B0:
	0: ImmBorrowLoc[0](Arg0: address)
	1: Call bcs::to_bytes<address>(&address): vector<u8>
	2: Ret
}

public to_ascii_string(Arg0: address): String {
B0:
	0: MoveLoc[0](Arg0: address)
	1: Call to_bytes(address): vector<u8>
	2: Call hex::encode(vector<u8>): vector<u8>
	3: Call ascii::string(vector<u8>): String
	4: Ret
}

public to_string(Arg0: address): String {
B0:
	0: MoveLoc[0](Arg0: address)
	1: Call to_ascii_string(address): String
	2: Call string::from_ascii(String): String
	3: Ret
}

public from_ascii_bytes(Arg0: &vector<u8>): address {
L1:	loc0: vector<u8>
L2:	loc1: u8
L3:	loc2: u64
L4:	loc3: u8
B0:
	0: CopyLoc[0](Arg0: &vector<u8>)
	1: VecLen(6)
	2: LdU64(64)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &vector<u8>)
	7: Pop
	8: LdConst[2](u64: 0)
	9: Abort
B3:
	10: LdConst[3](vector<u8>: "" /..)
	11: StLoc[1](loc0: vector<u8>)
	12: LdU64(0)
	13: StLoc[3](loc2: u64)
B4:
	14: CopyLoc[3](loc2: u64)
	15: LdU64(64)
	16: Lt
	17: BrFalse(44)
B5:
	18: CopyLoc[0](Arg0: &vector<u8>)
	19: CopyLoc[3](loc2: u64)
	20: VecImmBorrow(6)
	21: ReadRef
	22: Call hex_char_value(u8): u8
	23: StLoc[2](loc1: u8)
	24: CopyLoc[0](Arg0: &vector<u8>)
	25: CopyLoc[3](loc2: u64)
	26: LdU64(1)
	27: Add
	28: VecImmBorrow(6)
	29: ReadRef
	30: Call hex_char_value(u8): u8
	31: StLoc[4](loc3: u8)
	32: MutBorrowLoc[1](loc0: vector<u8>)
	33: MoveLoc[2](loc1: u8)
	34: LdU8(4)
	35: Shl
	36: MoveLoc[4](loc3: u8)
	37: BitOr
	38: VecPushBack(6)
	39: MoveLoc[3](loc2: u64)
	40: LdU64(2)
	41: Add
	42: StLoc[3](loc2: u64)
	43: Branch(14)
B6:
	44: MoveLoc[0](Arg0: &vector<u8>)
	45: Pop
	46: MoveLoc[1](loc0: vector<u8>)
	47: Call from_bytes(vector<u8>): address
	48: Ret
}

hex_char_value(Arg0: u8): u8 {
L1:	loc0: bool
L2:	loc1: bool
L3:	loc2: bool
L4:	loc3: u8
L5:	loc4: u8
B0:
	0: CopyLoc[0](Arg0: u8)
	1: LdU8(48)
	2: Ge
	3: BrFalse(9)
B1:
	4: CopyLoc[0](Arg0: u8)
	5: LdU8(57)
	6: Le
	7: StLoc[1](loc0: bool)
	8: Branch(11)
B2:
	9: LdFalse
	10: StLoc[1](loc0: bool)
B3:
	11: MoveLoc[1](loc0: bool)
	12: BrFalse(18)
B4:
	13: MoveLoc[0](Arg0: u8)
	14: LdU8(48)
	15: Sub
	16: StLoc[5](loc4: u8)
	17: Branch(58)
B5:
	18: CopyLoc[0](Arg0: u8)
	19: LdU8(65)
	20: Ge
	21: BrFalse(27)
B6:
	22: CopyLoc[0](Arg0: u8)
	23: LdU8(70)
	24: Le
	25: StLoc[2](loc1: bool)
	26: Branch(29)
B7:
	27: LdFalse
	28: StLoc[2](loc1: bool)
B8:
	29: MoveLoc[2](loc1: bool)
	30: BrFalse(36)
B9:
	31: MoveLoc[0](Arg0: u8)
	32: LdU8(55)
	33: Sub
	34: StLoc[4](loc3: u8)
	35: Branch(56)
B10:
	36: CopyLoc[0](Arg0: u8)
	37: LdU8(97)
	38: Ge
	39: BrFalse(45)
B11:
	40: CopyLoc[0](Arg0: u8)
	41: LdU8(102)
	42: Le
	43: StLoc[3](loc2: bool)
	44: Branch(47)
B12:
	45: LdFalse
	46: StLoc[3](loc2: bool)
B13:
	47: MoveLoc[3](loc2: bool)
	48: BrFalse(50)
B14:
	49: Branch(52)
B15:
	50: LdConst[2](u64: 0)
	51: Abort
B16:
	52: MoveLoc[0](Arg0: u8)
	53: LdU8(87)
	54: Sub
	55: StLoc[4](loc3: u8)
B17:
	56: MoveLoc[4](loc3: u8)
	57: StLoc[5](loc4: u8)
B18:
	58: MoveLoc[5](loc4: u8)
	59: Ret
}

public length(): u64 {
B0:
	0: LdConst[0](u64: 32)
	1: Ret
}

public max(): u256 {
B0:
	0: LdConst[1](u256: 1157..)
	1: Ret
}

Constants [
	0 => u64: 32
	1 => u256: 115792089237316195423570985008687907853269984665640564039457584007913129639935
	2 => u64: 0
	3 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 2.authenticator_state {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;

struct AuthenticatorState has key {
	id: UID,
	version: u64
}

struct AuthenticatorStateInner has store {
	version: u64,
	active_jwks: vector<ActiveJwk>
}

struct JWK has copy, drop, store {
	kty: String,
	e: String,
	n: String,
	alg: String
}

struct JwkId has copy, drop, store {
	iss: String,
	kid: String
}

struct ActiveJwk has copy, drop, store {
	jwk_id: JwkId,
	jwk: JWK,
	epoch: u64
}

active_jwk_equal(Arg0: &ActiveJwk, Arg1: &ActiveJwk): bool {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &ActiveJwk)
	1: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	2: CopyLoc[1](Arg1: &ActiveJwk)
	3: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	4: Call jwk_equal(&JWK, &JWK): bool
	5: BrFalse(13)
B1:
	6: MoveLoc[0](Arg0: &ActiveJwk)
	7: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	8: MoveLoc[1](Arg1: &ActiveJwk)
	9: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	10: Call jwk_id_equal(&JwkId, &JwkId): bool
	11: StLoc[2](loc0: bool)
	12: Branch(19)
B2:
	13: MoveLoc[1](Arg1: &ActiveJwk)
	14: Pop
	15: MoveLoc[0](Arg0: &ActiveJwk)
	16: Pop
	17: LdFalse
	18: StLoc[2](loc0: bool)
B3:
	19: MoveLoc[2](loc0: bool)
	20: Ret
}

jwk_equal(Arg0: &JWK, Arg1: &JWK): bool {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &JWK)
	1: ImmBorrowField[2](JWK.kty: String)
	2: CopyLoc[1](Arg1: &JWK)
	3: ImmBorrowField[2](JWK.kty: String)
	4: Eq
	5: BrFalse(39)
B1:
	6: CopyLoc[0](Arg0: &JWK)
	7: ImmBorrowField[3](JWK.e: String)
	8: CopyLoc[1](Arg1: &JWK)
	9: ImmBorrowField[3](JWK.e: String)
	10: Eq
	11: BrFalse(32)
B2:
	12: CopyLoc[0](Arg0: &JWK)
	13: ImmBorrowField[4](JWK.n: String)
	14: CopyLoc[1](Arg1: &JWK)
	15: ImmBorrowField[4](JWK.n: String)
	16: Eq
	17: BrFalse(25)
B3:
	18: MoveLoc[0](Arg0: &JWK)
	19: ImmBorrowField[5](JWK.alg: String)
	20: MoveLoc[1](Arg1: &JWK)
	21: ImmBorrowField[5](JWK.alg: String)
	22: Eq
	23: StLoc[2](loc0: bool)
	24: Branch(45)
B4:
	25: MoveLoc[1](Arg1: &JWK)
	26: Pop
	27: MoveLoc[0](Arg0: &JWK)
	28: Pop
	29: LdFalse
	30: StLoc[2](loc0: bool)
	31: Branch(45)
B5:
	32: MoveLoc[1](Arg1: &JWK)
	33: Pop
	34: MoveLoc[0](Arg0: &JWK)
	35: Pop
	36: LdFalse
	37: StLoc[2](loc0: bool)
	38: Branch(45)
B6:
	39: MoveLoc[1](Arg1: &JWK)
	40: Pop
	41: MoveLoc[0](Arg0: &JWK)
	42: Pop
	43: LdFalse
	44: StLoc[2](loc0: bool)
B7:
	45: MoveLoc[2](loc0: bool)
	46: Ret
}

jwk_id_equal(Arg0: &JwkId, Arg1: &JwkId): bool {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &JwkId)
	1: ImmBorrowField[6](JwkId.iss: String)
	2: CopyLoc[1](Arg1: &JwkId)
	3: ImmBorrowField[6](JwkId.iss: String)
	4: Eq
	5: BrFalse(13)
B1:
	6: MoveLoc[0](Arg0: &JwkId)
	7: ImmBorrowField[7](JwkId.kid: String)
	8: MoveLoc[1](Arg1: &JwkId)
	9: ImmBorrowField[7](JwkId.kid: String)
	10: Eq
	11: StLoc[2](loc0: bool)
	12: Branch(19)
B2:
	13: MoveLoc[1](Arg1: &JwkId)
	14: Pop
	15: MoveLoc[0](Arg0: &JwkId)
	16: Pop
	17: LdFalse
	18: StLoc[2](loc0: bool)
B3:
	19: MoveLoc[2](loc0: bool)
	20: Ret
}

string_bytes_lt(Arg0: &String, Arg1: &String): bool {
L2:	loc0: bool
L3:	loc1: bool
L4:	loc2: u8
L5:	loc3: &vector<u8>
L6:	loc4: u8
L7:	loc5: &vector<u8>
L8:	loc6: u64
B0:
	0: MoveLoc[0](Arg0: &String)
	1: Call string::as_bytes(&String): &vector<u8>
	2: StLoc[5](loc3: &vector<u8>)
	3: MoveLoc[1](Arg1: &String)
	4: Call string::as_bytes(&String): &vector<u8>
	5: StLoc[7](loc5: &vector<u8>)
	6: CopyLoc[5](loc3: &vector<u8>)
	7: VecLen(19)
	8: CopyLoc[7](loc5: &vector<u8>)
	9: VecLen(19)
	10: Lt
	11: BrFalse(19)
B1:
	12: MoveLoc[7](loc5: &vector<u8>)
	13: Pop
	14: MoveLoc[5](loc3: &vector<u8>)
	15: Pop
	16: LdTrue
	17: StLoc[3](loc1: bool)
	18: Branch(83)
B2:
	19: CopyLoc[5](loc3: &vector<u8>)
	20: VecLen(19)
	21: CopyLoc[7](loc5: &vector<u8>)
	22: VecLen(19)
	23: Gt
	24: BrFalse(32)
B3:
	25: MoveLoc[7](loc5: &vector<u8>)
	26: Pop
	27: MoveLoc[5](loc3: &vector<u8>)
	28: Pop
	29: LdFalse
	30: StLoc[2](loc0: bool)
	31: Branch(81)
B4:
	32: LdU64(0)
	33: StLoc[8](loc6: u64)
B5:
	34: CopyLoc[8](loc6: u64)
	35: CopyLoc[5](loc3: &vector<u8>)
	36: VecLen(19)
	37: Lt
	38: BrFalse(75)
B6:
	39: Branch(40)
B7:
	40: CopyLoc[5](loc3: &vector<u8>)
	41: CopyLoc[8](loc6: u64)
	42: VecImmBorrow(19)
	43: ReadRef
	44: StLoc[4](loc2: u8)
	45: CopyLoc[7](loc5: &vector<u8>)
	46: CopyLoc[8](loc6: u64)
	47: VecImmBorrow(19)
	48: ReadRef
	49: StLoc[6](loc4: u8)
	50: CopyLoc[4](loc2: u8)
	51: CopyLoc[6](loc4: u8)
	52: Lt
	53: BrFalse(60)
B8:
	54: MoveLoc[7](loc5: &vector<u8>)
	55: Pop
	56: MoveLoc[5](loc3: &vector<u8>)
	57: Pop
	58: LdTrue
	59: Ret
B9:
	60: MoveLoc[4](loc2: u8)
	61: MoveLoc[6](loc4: u8)
	62: Gt
	63: BrFalse(70)
B10:
	64: MoveLoc[7](loc5: &vector<u8>)
	65: Pop
	66: MoveLoc[5](loc3: &vector<u8>)
	67: Pop
	68: LdFalse
	69: Ret
B11:
	70: MoveLoc[8](loc6: u64)
	71: LdU64(1)
	72: Add
	73: StLoc[8](loc6: u64)
	74: Branch(34)
B12:
	75: MoveLoc[7](loc5: &vector<u8>)
	76: Pop
	77: MoveLoc[5](loc3: &vector<u8>)
	78: Pop
	79: LdFalse
	80: StLoc[2](loc0: bool)
B13:
	81: MoveLoc[2](loc0: bool)
	82: StLoc[3](loc1: bool)
B14:
	83: MoveLoc[3](loc1: bool)
	84: Ret
}

jwk_lt(Arg0: &ActiveJwk, Arg1: &ActiveJwk): bool {
B0:
	0: CopyLoc[0](Arg0: &ActiveJwk)
	1: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	2: ImmBorrowField[6](JwkId.iss: String)
	3: CopyLoc[1](Arg1: &ActiveJwk)
	4: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	5: ImmBorrowField[6](JwkId.iss: String)
	6: Neq
	7: BrFalse(16)
B1:
	8: MoveLoc[0](Arg0: &ActiveJwk)
	9: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	10: ImmBorrowField[6](JwkId.iss: String)
	11: MoveLoc[1](Arg1: &ActiveJwk)
	12: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	13: ImmBorrowField[6](JwkId.iss: String)
	14: Call string_bytes_lt(&String, &String): bool
	15: Ret
B2:
	16: CopyLoc[0](Arg0: &ActiveJwk)
	17: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	18: ImmBorrowField[7](JwkId.kid: String)
	19: CopyLoc[1](Arg1: &ActiveJwk)
	20: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	21: ImmBorrowField[7](JwkId.kid: String)
	22: Neq
	23: BrFalse(32)
B3:
	24: MoveLoc[0](Arg0: &ActiveJwk)
	25: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	26: ImmBorrowField[7](JwkId.kid: String)
	27: MoveLoc[1](Arg1: &ActiveJwk)
	28: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	29: ImmBorrowField[7](JwkId.kid: String)
	30: Call string_bytes_lt(&String, &String): bool
	31: Ret
B4:
	32: CopyLoc[0](Arg0: &ActiveJwk)
	33: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	34: ImmBorrowField[2](JWK.kty: String)
	35: CopyLoc[1](Arg1: &ActiveJwk)
	36: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	37: ImmBorrowField[2](JWK.kty: String)
	38: Neq
	39: BrFalse(48)
B5:
	40: MoveLoc[0](Arg0: &ActiveJwk)
	41: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	42: ImmBorrowField[2](JWK.kty: String)
	43: MoveLoc[1](Arg1: &ActiveJwk)
	44: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	45: ImmBorrowField[2](JWK.kty: String)
	46: Call string_bytes_lt(&String, &String): bool
	47: Ret
B6:
	48: CopyLoc[0](Arg0: &ActiveJwk)
	49: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	50: ImmBorrowField[3](JWK.e: String)
	51: CopyLoc[1](Arg1: &ActiveJwk)
	52: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	53: ImmBorrowField[3](JWK.e: String)
	54: Neq
	55: BrFalse(64)
B7:
	56: MoveLoc[0](Arg0: &ActiveJwk)
	57: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	58: ImmBorrowField[3](JWK.e: String)
	59: MoveLoc[1](Arg1: &ActiveJwk)
	60: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	61: ImmBorrowField[3](JWK.e: String)
	62: Call string_bytes_lt(&String, &String): bool
	63: Ret
B8:
	64: CopyLoc[0](Arg0: &ActiveJwk)
	65: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	66: ImmBorrowField[4](JWK.n: String)
	67: CopyLoc[1](Arg1: &ActiveJwk)
	68: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	69: ImmBorrowField[4](JWK.n: String)
	70: Neq
	71: BrFalse(80)
B9:
	72: MoveLoc[0](Arg0: &ActiveJwk)
	73: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	74: ImmBorrowField[4](JWK.n: String)
	75: MoveLoc[1](Arg1: &ActiveJwk)
	76: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	77: ImmBorrowField[4](JWK.n: String)
	78: Call string_bytes_lt(&String, &String): bool
	79: Ret
B10:
	80: MoveLoc[0](Arg0: &ActiveJwk)
	81: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	82: ImmBorrowField[5](JWK.alg: String)
	83: MoveLoc[1](Arg1: &ActiveJwk)
	84: ImmBorrowField[0](ActiveJwk.jwk: JWK)
	85: ImmBorrowField[5](JWK.alg: String)
	86: Call string_bytes_lt(&String, &String): bool
	87: Ret
}

create(Arg0: &TxContext) {
L1:	loc0: AuthenticatorStateInner
L2:	loc1: AuthenticatorState
L3:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[3](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: LdConst[1](u64: 1)
	9: StLoc[3](loc2: u64)
	10: CopyLoc[3](loc2: u64)
	11: VecPack(22, 0)
	12: Pack[1](AuthenticatorStateInner)
	13: StLoc[1](loc0: AuthenticatorStateInner)
	14: Call object::authenticator_state(): UID
	15: CopyLoc[3](loc2: u64)
	16: Pack[0](AuthenticatorState)
	17: StLoc[2](loc1: AuthenticatorState)
	18: MutBorrowLoc[2](loc1: AuthenticatorState)
	19: MutBorrowField[8](AuthenticatorState.id: UID)
	20: MoveLoc[3](loc2: u64)
	21: MoveLoc[1](loc0: AuthenticatorStateInner)
	22: Call dynamic_field::add<u64, AuthenticatorStateInner>(&mut UID, u64, AuthenticatorStateInner)
	23: MoveLoc[2](loc1: AuthenticatorState)
	24: Call transfer::share_object<AuthenticatorState>(AuthenticatorState)
	25: Ret
}

load_inner_mut(Arg0: &mut AuthenticatorState): &mut AuthenticatorStateInner {
L1:	loc0: &mut AuthenticatorStateInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &mut AuthenticatorState)
	1: ImmBorrowField[9](AuthenticatorState.version: u64)
	2: ReadRef
	3: StLoc[2](loc1: u64)
	4: CopyLoc[2](loc1: u64)
	5: LdConst[1](u64: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut AuthenticatorState)
	10: Pop
	11: LdConst[1](u64: 1)
	12: Abort
B3:
	13: CopyLoc[0](Arg0: &mut AuthenticatorState)
	14: MutBorrowField[8](AuthenticatorState.id: UID)
	15: MoveLoc[0](Arg0: &mut AuthenticatorState)
	16: ImmBorrowField[9](AuthenticatorState.version: u64)
	17: ReadRef
	18: Call dynamic_field::borrow_mut<u64, AuthenticatorStateInner>(&mut UID, u64): &mut AuthenticatorStateInner
	19: StLoc[1](loc0: &mut AuthenticatorStateInner)
	20: CopyLoc[1](loc0: &mut AuthenticatorStateInner)
	21: ImmBorrowField[10](AuthenticatorStateInner.version: u64)
	22: ReadRef
	23: MoveLoc[2](loc1: u64)
	24: Eq
	25: BrFalse(27)
B4:
	26: Branch(31)
B5:
	27: MoveLoc[1](loc0: &mut AuthenticatorStateInner)
	28: Pop
	29: LdConst[1](u64: 1)
	30: Abort
B6:
	31: MoveLoc[1](loc0: &mut AuthenticatorStateInner)
	32: Ret
}

load_inner(Arg0: &AuthenticatorState): &AuthenticatorStateInner {
L1:	loc0: &AuthenticatorStateInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &AuthenticatorState)
	1: ImmBorrowField[9](AuthenticatorState.version: u64)
	2: ReadRef
	3: StLoc[2](loc1: u64)
	4: CopyLoc[2](loc1: u64)
	5: LdConst[1](u64: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &AuthenticatorState)
	10: Pop
	11: LdConst[1](u64: 1)
	12: Abort
B3:
	13: CopyLoc[0](Arg0: &AuthenticatorState)
	14: ImmBorrowField[8](AuthenticatorState.id: UID)
	15: MoveLoc[0](Arg0: &AuthenticatorState)
	16: ImmBorrowField[9](AuthenticatorState.version: u64)
	17: ReadRef
	18: Call dynamic_field::borrow<u64, AuthenticatorStateInner>(&UID, u64): &AuthenticatorStateInner
	19: StLoc[1](loc0: &AuthenticatorStateInner)
	20: CopyLoc[1](loc0: &AuthenticatorStateInner)
	21: ImmBorrowField[10](AuthenticatorStateInner.version: u64)
	22: ReadRef
	23: MoveLoc[2](loc1: u64)
	24: Eq
	25: BrFalse(27)
B4:
	26: Branch(31)
B5:
	27: MoveLoc[1](loc0: &AuthenticatorStateInner)
	28: Pop
	29: LdConst[1](u64: 1)
	30: Abort
B6:
	31: MoveLoc[1](loc0: &AuthenticatorStateInner)
	32: Ret
}

check_sorted(Arg0: &vector<ActiveJwk>) {
L1:	loc0: &ActiveJwk
L2:	loc1: &ActiveJwk
L3:	loc2: u64
B0:
	0: LdU64(0)
	1: StLoc[3](loc2: u64)
B1:
	2: CopyLoc[3](loc2: u64)
	3: CopyLoc[0](Arg0: &vector<ActiveJwk>)
	4: VecLen(22)
	5: LdU64(1)
	6: Sub
	7: Lt
	8: BrFalse(34)
B2:
	9: Branch(10)
B3:
	10: CopyLoc[0](Arg0: &vector<ActiveJwk>)
	11: CopyLoc[3](loc2: u64)
	12: VecImmBorrow(22)
	13: StLoc[1](loc0: &ActiveJwk)
	14: CopyLoc[0](Arg0: &vector<ActiveJwk>)
	15: CopyLoc[3](loc2: u64)
	16: LdU64(1)
	17: Add
	18: VecImmBorrow(22)
	19: StLoc[2](loc1: &ActiveJwk)
	20: MoveLoc[1](loc0: &ActiveJwk)
	21: MoveLoc[2](loc1: &ActiveJwk)
	22: Call jwk_lt(&ActiveJwk, &ActiveJwk): bool
	23: BrFalse(25)
B4:
	24: Branch(29)
B5:
	25: MoveLoc[0](Arg0: &vector<ActiveJwk>)
	26: Pop
	27: LdConst[2](u64: 2)
	28: Abort
B6:
	29: MoveLoc[3](loc2: u64)
	30: LdU64(1)
	31: Add
	32: StLoc[3](loc2: u64)
	33: Branch(2)
B7:
	34: MoveLoc[0](Arg0: &vector<ActiveJwk>)
	35: Pop
	36: Ret
}

update_authenticator_state(Arg0: &mut AuthenticatorState, Arg1: vector<ActiveJwk>, Arg2: &TxContext) {
L3:	loc0: bool
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: &mut AuthenticatorStateInner
L7:	loc4: u64
L8:	loc5: ActiveJwk
L9:	loc6: vector<ActiveJwk>
L10:	loc7: u64
L11:	loc8: &ActiveJwk
L12:	loc9: &ActiveJwk
L13:	loc10: vector<ActiveJwk>
B0:
	0: MoveLoc[2](Arg2: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[3](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut AuthenticatorState)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: ImmBorrowLoc[1](Arg1: vector<ActiveJwk>)
	11: Call check_sorted(&vector<ActiveJwk>)
	12: MoveLoc[1](Arg1: vector<ActiveJwk>)
	13: Call deduplicate(vector<ActiveJwk>): vector<ActiveJwk>
	14: StLoc[9](loc6: vector<ActiveJwk>)
	15: MoveLoc[0](Arg0: &mut AuthenticatorState)
	16: Call load_inner_mut(&mut AuthenticatorState): &mut AuthenticatorStateInner
	17: StLoc[6](loc3: &mut AuthenticatorStateInner)
	18: VecPack(22, 0)
	19: StLoc[13](loc10: vector<ActiveJwk>)
	20: LdU64(0)
	21: StLoc[5](loc2: u64)
	22: LdU64(0)
	23: StLoc[7](loc4: u64)
	24: CopyLoc[6](loc3: &mut AuthenticatorStateInner)
	25: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	26: VecLen(22)
	27: StLoc[4](loc1: u64)
	28: ImmBorrowLoc[9](loc6: vector<ActiveJwk>)
	29: VecLen(22)
	30: StLoc[10](loc7: u64)
B4:
	31: CopyLoc[5](loc2: u64)
	32: CopyLoc[4](loc1: u64)
	33: Lt
	34: BrFalse(40)
B5:
	35: CopyLoc[7](loc4: u64)
	36: CopyLoc[10](loc7: u64)
	37: Lt
	38: StLoc[3](loc0: bool)
	39: Branch(42)
B6:
	40: LdFalse
	41: StLoc[3](loc0: bool)
B7:
	42: MoveLoc[3](loc0: bool)
	43: BrFalse(129)
B8:
	44: CopyLoc[6](loc3: &mut AuthenticatorStateInner)
	45: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	46: CopyLoc[5](loc2: u64)
	47: VecImmBorrow(22)
	48: StLoc[12](loc9: &ActiveJwk)
	49: ImmBorrowLoc[9](loc6: vector<ActiveJwk>)
	50: CopyLoc[7](loc4: u64)
	51: VecImmBorrow(22)
	52: StLoc[11](loc8: &ActiveJwk)
	53: CopyLoc[12](loc9: &ActiveJwk)
	54: CopyLoc[11](loc8: &ActiveJwk)
	55: Call active_jwk_equal(&ActiveJwk, &ActiveJwk): bool
	56: BrFalse(82)
B9:
	57: CopyLoc[12](loc9: &ActiveJwk)
	58: ReadRef
	59: StLoc[8](loc5: ActiveJwk)
	60: MoveLoc[12](loc9: &ActiveJwk)
	61: ImmBorrowField[12](ActiveJwk.epoch: u64)
	62: ReadRef
	63: MoveLoc[11](loc8: &ActiveJwk)
	64: ImmBorrowField[12](ActiveJwk.epoch: u64)
	65: ReadRef
	66: Call u64::max(u64, u64): u64
	67: MutBorrowLoc[8](loc5: ActiveJwk)
	68: MutBorrowField[12](ActiveJwk.epoch: u64)
	69: WriteRef
	70: MutBorrowLoc[13](loc10: vector<ActiveJwk>)
	71: MoveLoc[8](loc5: ActiveJwk)
	72: VecPushBack(22)
	73: MoveLoc[5](loc2: u64)
	74: LdU64(1)
	75: Add
	76: StLoc[5](loc2: u64)
	77: MoveLoc[7](loc4: u64)
	78: LdU64(1)
	79: Add
	80: StLoc[7](loc4: u64)
	81: Branch(31)
B10:
	82: CopyLoc[12](loc9: &ActiveJwk)
	83: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	84: CopyLoc[11](loc8: &ActiveJwk)
	85: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	86: Call jwk_id_equal(&JwkId, &JwkId): bool
	87: BrFalse(103)
B11:
	88: MoveLoc[11](loc8: &ActiveJwk)
	89: Pop
	90: MutBorrowLoc[13](loc10: vector<ActiveJwk>)
	91: MoveLoc[12](loc9: &ActiveJwk)
	92: ReadRef
	93: VecPushBack(22)
	94: MoveLoc[5](loc2: u64)
	95: LdU64(1)
	96: Add
	97: StLoc[5](loc2: u64)
	98: MoveLoc[7](loc4: u64)
	99: LdU64(1)
	100: Add
	101: StLoc[7](loc4: u64)
	102: Branch(31)
B12:
	103: CopyLoc[12](loc9: &ActiveJwk)
	104: CopyLoc[11](loc8: &ActiveJwk)
	105: Call jwk_lt(&ActiveJwk, &ActiveJwk): bool
	106: BrFalse(118)
B13:
	107: MoveLoc[11](loc8: &ActiveJwk)
	108: Pop
	109: MutBorrowLoc[13](loc10: vector<ActiveJwk>)
	110: MoveLoc[12](loc9: &ActiveJwk)
	111: ReadRef
	112: VecPushBack(22)
	113: MoveLoc[5](loc2: u64)
	114: LdU64(1)
	115: Add
	116: StLoc[5](loc2: u64)
	117: Branch(31)
B14:
	118: MoveLoc[12](loc9: &ActiveJwk)
	119: Pop
	120: MutBorrowLoc[13](loc10: vector<ActiveJwk>)
	121: MoveLoc[11](loc8: &ActiveJwk)
	122: ReadRef
	123: VecPushBack(22)
	124: MoveLoc[7](loc4: u64)
	125: LdU64(1)
	126: Add
	127: StLoc[7](loc4: u64)
	128: Branch(31)
B15:
	129: CopyLoc[5](loc2: u64)
	130: CopyLoc[4](loc1: u64)
	131: Lt
	132: BrFalse(145)
B16:
	133: MutBorrowLoc[13](loc10: vector<ActiveJwk>)
	134: CopyLoc[6](loc3: &mut AuthenticatorStateInner)
	135: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	136: CopyLoc[5](loc2: u64)
	137: VecImmBorrow(22)
	138: ReadRef
	139: VecPushBack(22)
	140: MoveLoc[5](loc2: u64)
	141: LdU64(1)
	142: Add
	143: StLoc[5](loc2: u64)
	144: Branch(129)
B17:
	145: CopyLoc[7](loc4: u64)
	146: CopyLoc[10](loc7: u64)
	147: Lt
	148: BrFalse(160)
B18:
	149: MutBorrowLoc[13](loc10: vector<ActiveJwk>)
	150: ImmBorrowLoc[9](loc6: vector<ActiveJwk>)
	151: CopyLoc[7](loc4: u64)
	152: VecImmBorrow(22)
	153: ReadRef
	154: VecPushBack(22)
	155: MoveLoc[7](loc4: u64)
	156: LdU64(1)
	157: Add
	158: StLoc[7](loc4: u64)
	159: Branch(145)
B19:
	160: MoveLoc[13](loc10: vector<ActiveJwk>)
	161: MoveLoc[6](loc3: &mut AuthenticatorStateInner)
	162: MutBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	163: WriteRef
	164: Ret
}

deduplicate(Arg0: vector<ActiveJwk>): vector<ActiveJwk> {
L1:	loc0: u64
L2:	loc1: &ActiveJwk
L3:	loc2: Option<JwkId>
L4:	loc3: vector<ActiveJwk>
B0:
	0: VecPack(22, 0)
	1: StLoc[4](loc3: vector<ActiveJwk>)
	2: LdU64(0)
	3: StLoc[1](loc0: u64)
	4: Call option::none<JwkId>(): Option<JwkId>
	5: StLoc[3](loc2: Option<JwkId>)
B1:
	6: CopyLoc[1](loc0: u64)
	7: ImmBorrowLoc[0](Arg0: vector<ActiveJwk>)
	8: VecLen(22)
	9: Lt
	10: BrFalse(53)
B2:
	11: Branch(12)
B3:
	12: ImmBorrowLoc[0](Arg0: vector<ActiveJwk>)
	13: CopyLoc[1](loc0: u64)
	14: VecImmBorrow(22)
	15: StLoc[2](loc1: &ActiveJwk)
	16: ImmBorrowLoc[3](loc2: Option<JwkId>)
	17: Call option::is_none<JwkId>(&Option<JwkId>): bool
	18: BrFalse(25)
B4:
	19: MutBorrowLoc[3](loc2: Option<JwkId>)
	20: CopyLoc[2](loc1: &ActiveJwk)
	21: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	22: ReadRef
	23: Call option::fill<JwkId>(&mut Option<JwkId>, JwkId)
	24: Branch(44)
B5:
	25: ImmBorrowLoc[3](loc2: Option<JwkId>)
	26: Call option::borrow<JwkId>(&Option<JwkId>): &JwkId
	27: CopyLoc[2](loc1: &ActiveJwk)
	28: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	29: Call jwk_id_equal(&JwkId, &JwkId): bool
	30: BrFalse(38)
B6:
	31: MoveLoc[2](loc1: &ActiveJwk)
	32: Pop
	33: MoveLoc[1](loc0: u64)
	34: LdU64(1)
	35: Add
	36: StLoc[1](loc0: u64)
	37: Branch(6)
B7:
	38: CopyLoc[2](loc1: &ActiveJwk)
	39: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	40: ReadRef
	41: MutBorrowLoc[3](loc2: Option<JwkId>)
	42: Call option::borrow_mut<JwkId>(&mut Option<JwkId>): &mut JwkId
	43: WriteRef
B8:
	44: MutBorrowLoc[4](loc3: vector<ActiveJwk>)
	45: MoveLoc[2](loc1: &ActiveJwk)
	46: ReadRef
	47: VecPushBack(22)
	48: MoveLoc[1](loc0: u64)
	49: LdU64(1)
	50: Add
	51: StLoc[1](loc0: u64)
	52: Branch(6)
B9:
	53: MoveLoc[4](loc3: vector<ActiveJwk>)
	54: Ret
}

expire_jwks(Arg0: &mut AuthenticatorState, Arg1: u64, Arg2: &TxContext) {
L3:	loc0: bool
L4:	loc1: u64
L5:	loc2: &ActiveJwk
L6:	loc3: &String
L7:	loc4: &String
L8:	loc5: u64
L9:	loc6: u64
L10:	loc7: &mut AuthenticatorStateInner
L11:	loc8: vector<u64>
L12:	loc9: u64
L13:	loc10: &ActiveJwk
L14:	loc11: u64
L15:	loc12: vector<ActiveJwk>
L16:	loc13: Option<String>
L17:	loc14: Option<String>
L18:	loc15: &mut u64
B0:
	0: MoveLoc[2](Arg2: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[3](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut AuthenticatorState)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: MoveLoc[0](Arg0: &mut AuthenticatorState)
	11: Call load_inner_mut(&mut AuthenticatorState): &mut AuthenticatorStateInner
	12: StLoc[10](loc7: &mut AuthenticatorStateInner)
	13: CopyLoc[10](loc7: &mut AuthenticatorStateInner)
	14: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	15: VecLen(22)
	16: StLoc[14](loc11: u64)
	17: LdConst[4](vector<u64>: 00)
	18: StLoc[11](loc8: vector<u64>)
	19: LdU64(0)
	20: StLoc[8](loc5: u64)
	21: Call option::none<String>(): Option<String>
	22: StLoc[16](loc13: Option<String>)
B4:
	23: CopyLoc[8](loc5: u64)
	24: CopyLoc[14](loc11: u64)
	25: Lt
	26: BrFalse(90)
B5:
	27: CopyLoc[10](loc7: &mut AuthenticatorStateInner)
	28: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	29: CopyLoc[8](loc5: u64)
	30: VecImmBorrow(22)
	31: StLoc[5](loc2: &ActiveJwk)
	32: CopyLoc[5](loc2: &ActiveJwk)
	33: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	34: ImmBorrowField[6](JwkId.iss: String)
	35: StLoc[6](loc3: &String)
	36: ImmBorrowLoc[16](loc13: Option<String>)
	37: Call option::is_none<String>(&Option<String>): bool
	38: BrFalse(50)
B6:
	39: Branch(40)
B7:
	40: MutBorrowLoc[16](loc13: Option<String>)
	41: MoveLoc[6](loc3: &String)
	42: ReadRef
	43: Call option::fill<String>(&mut Option<String>, String)
	44: MutBorrowLoc[11](loc8: vector<u64>)
	45: MoveLoc[5](loc2: &ActiveJwk)
	46: ImmBorrowField[12](ActiveJwk.epoch: u64)
	47: ReadRef
	48: VecPushBack(37)
	49: Branch(85)
B8:
	50: CopyLoc[6](loc3: &String)
	51: ImmBorrowLoc[16](loc13: Option<String>)
	52: Call option::borrow<String>(&Option<String>): &String
	53: Eq
	54: BrFalse(75)
B9:
	55: MoveLoc[6](loc3: &String)
	56: Pop
	57: ImmBorrowLoc[11](loc8: vector<u64>)
	58: VecLen(37)
	59: LdU64(1)
	60: Sub
	61: StLoc[4](loc1: u64)
	62: MutBorrowLoc[11](loc8: vector<u64>)
	63: MoveLoc[4](loc1: u64)
	64: VecMutBorrow(37)
	65: StLoc[18](loc15: &mut u64)
	66: CopyLoc[18](loc15: &mut u64)
	67: ReadRef
	68: MoveLoc[5](loc2: &ActiveJwk)
	69: ImmBorrowField[12](ActiveJwk.epoch: u64)
	70: ReadRef
	71: Call u64::max(u64, u64): u64
	72: MoveLoc[18](loc15: &mut u64)
	73: WriteRef
	74: Branch(85)
B10:
	75: MoveLoc[6](loc3: &String)
	76: ReadRef
	77: MutBorrowLoc[16](loc13: Option<String>)
	78: Call option::borrow_mut<String>(&mut Option<String>): &mut String
	79: WriteRef
	80: MutBorrowLoc[11](loc8: vector<u64>)
	81: MoveLoc[5](loc2: &ActiveJwk)
	82: ImmBorrowField[12](ActiveJwk.epoch: u64)
	83: ReadRef
	84: VecPushBack(37)
B11:
	85: MoveLoc[8](loc5: u64)
	86: LdU64(1)
	87: Add
	88: StLoc[8](loc5: u64)
	89: Branch(23)
B12:
	90: VecPack(22, 0)
	91: StLoc[15](loc12: vector<ActiveJwk>)
	92: Call option::none<String>(): Option<String>
	93: StLoc[17](loc14: Option<String>)
	94: LdU64(0)
	95: StLoc[9](loc6: u64)
	96: LdU64(0)
	97: StLoc[12](loc9: u64)
B13:
	98: CopyLoc[9](loc6: u64)
	99: CopyLoc[14](loc11: u64)
	100: Lt
	101: BrFalse(166)
B14:
	102: CopyLoc[10](loc7: &mut AuthenticatorStateInner)
	103: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	104: CopyLoc[9](loc6: u64)
	105: VecImmBorrow(22)
	106: StLoc[13](loc10: &ActiveJwk)
	107: CopyLoc[13](loc10: &ActiveJwk)
	108: ImmBorrowField[1](ActiveJwk.jwk_id: JwkId)
	109: ImmBorrowField[6](JwkId.iss: String)
	110: StLoc[7](loc4: &String)
	111: ImmBorrowLoc[17](loc14: Option<String>)
	112: Call option::is_none<String>(&Option<String>): bool
	113: BrFalse(119)
B15:
	114: MutBorrowLoc[17](loc14: Option<String>)
	115: MoveLoc[7](loc4: &String)
	116: ReadRef
	117: Call option::fill<String>(&mut Option<String>, String)
	118: Branch(136)
B16:
	119: CopyLoc[7](loc4: &String)
	120: ImmBorrowLoc[17](loc14: Option<String>)
	121: Call option::borrow<String>(&Option<String>): &String
	122: Neq
	123: BrFalse(134)
B17:
	124: MoveLoc[7](loc4: &String)
	125: ReadRef
	126: MutBorrowLoc[17](loc14: Option<String>)
	127: Call option::borrow_mut<String>(&mut Option<String>): &mut String
	128: WriteRef
	129: MoveLoc[12](loc9: u64)
	130: LdU64(1)
	131: Add
	132: StLoc[12](loc9: u64)
	133: Branch(136)
B18:
	134: MoveLoc[7](loc4: &String)
	135: Pop
B19:
	136: ImmBorrowLoc[11](loc8: vector<u64>)
	137: CopyLoc[12](loc9: u64)
	138: VecImmBorrow(37)
	139: ReadRef
	140: CopyLoc[1](Arg1: u64)
	141: Lt
	142: BrFalse(146)
B20:
	143: LdTrue
	144: StLoc[3](loc0: bool)
	145: Branch(152)
B21:
	146: CopyLoc[13](loc10: &ActiveJwk)
	147: ImmBorrowField[12](ActiveJwk.epoch: u64)
	148: ReadRef
	149: CopyLoc[1](Arg1: u64)
	150: Ge
	151: StLoc[3](loc0: bool)
B22:
	152: MoveLoc[3](loc0: bool)
	153: BrFalse(159)
B23:
	154: MutBorrowLoc[15](loc12: vector<ActiveJwk>)
	155: MoveLoc[13](loc10: &ActiveJwk)
	156: ReadRef
	157: VecPushBack(22)
	158: Branch(161)
B24:
	159: MoveLoc[13](loc10: &ActiveJwk)
	160: Pop
B25:
	161: MoveLoc[9](loc6: u64)
	162: LdU64(1)
	163: Add
	164: StLoc[9](loc6: u64)
	165: Branch(98)
B26:
	166: MoveLoc[15](loc12: vector<ActiveJwk>)
	167: MoveLoc[10](loc7: &mut AuthenticatorStateInner)
	168: MutBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	169: WriteRef
	170: Ret
}

get_active_jwks(Arg0: &AuthenticatorState, Arg1: &TxContext): vector<ActiveJwk> {
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[3](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &AuthenticatorState)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: MoveLoc[0](Arg0: &AuthenticatorState)
	11: Call load_inner(&AuthenticatorState): &AuthenticatorStateInner
	12: ImmBorrowField[11](AuthenticatorStateInner.active_jwks: vector<ActiveJwk>)
	13: ReadRef
	14: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
	4 => vector<u64>: 00
]
}

// Move bytecode v6
module 2.bag {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Bag has store, key {
	id: UID,
	size: u64
}

public new(Arg0: &mut TxContext): Bag {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdU64(0)
	3: Pack[0](Bag)
	4: Ret
}

public add<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut Bag, Arg1: Ty0, Arg2: Ty1) {
B0:
	0: CopyLoc[0](Arg0: &mut Bag)
	1: MutBorrowField[0](Bag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: MoveLoc[2](Arg2: Ty1)
	4: Call dynamic_field::add<Ty0, Ty1>(&mut UID, Ty0, Ty1)
	5: CopyLoc[0](Arg0: &mut Bag)
	6: ImmBorrowField[1](Bag.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Add
	10: MoveLoc[0](Arg0: &mut Bag)
	11: MutBorrowField[1](Bag.size: u64)
	12: WriteRef
	13: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store>(Arg0: &Bag, Arg1: Ty0): &Ty1 {
B0:
	0: MoveLoc[0](Arg0: &Bag)
	1: ImmBorrowField[0](Bag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow<Ty0, Ty1>(&UID, Ty0): &Ty1
	4: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut Bag, Arg1: Ty0): &mut Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut Bag)
	1: MutBorrowField[0](Bag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow_mut<Ty0, Ty1>(&mut UID, Ty0): &mut Ty1
	4: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut Bag, Arg1: Ty0): Ty1 {
L2:	loc0: Ty1
B0:
	0: CopyLoc[0](Arg0: &mut Bag)
	1: MutBorrowField[0](Bag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::remove<Ty0, Ty1>(&mut UID, Ty0): Ty1
	4: StLoc[2](loc0: Ty1)
	5: CopyLoc[0](Arg0: &mut Bag)
	6: ImmBorrowField[1](Bag.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Sub
	10: MoveLoc[0](Arg0: &mut Bag)
	11: MutBorrowField[1](Bag.size: u64)
	12: WriteRef
	13: MoveLoc[2](loc0: Ty1)
	14: Ret
}

public contains<Ty0: copy + drop + store>(Arg0: &Bag, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &Bag)
	1: ImmBorrowField[0](Bag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::exists_<Ty0>(&UID, Ty0): bool
	4: Ret
}

public contains_with_type<Ty0: copy + drop + store, Ty1: store>(Arg0: &Bag, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &Bag)
	1: ImmBorrowField[0](Bag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::exists_with_type<Ty0, Ty1>(&UID, Ty0): bool
	4: Ret
}

public length(Arg0: &Bag): u64 {
B0:
	0: MoveLoc[0](Arg0: &Bag)
	1: ImmBorrowField[1](Bag.size: u64)
	2: ReadRef
	3: Ret
}

public is_empty(Arg0: &Bag): bool {
B0:
	0: MoveLoc[0](Arg0: &Bag)
	1: ImmBorrowField[1](Bag.size: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: Ret
}

public destroy_empty(Arg0: Bag) {
L1:	loc0: UID
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: Bag)
	1: Unpack[0](Bag)
	2: StLoc[2](loc1: u64)
	3: StLoc[1](loc0: UID)
	4: MoveLoc[2](loc1: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[1](loc0: UID)
	12: Call object::delete(UID)
	13: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.balance {
use 0000000000000000000000000000000000000000000000000000000000000002::accumulator;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

struct Supply<phantom Ty0> has store {
	value: u64
}

struct Balance<phantom Ty0> has store {
	value: u64
}

public value<Ty0>(Arg0: &Balance<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Balance<Ty0>)
	1: ImmBorrowFieldGeneric[0](Balance.value: u64)
	2: ReadRef
	3: Ret
}

public supply_value<Ty0>(Arg0: &Supply<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Supply<Ty0>)
	1: ImmBorrowFieldGeneric[1](Supply.value: u64)
	2: ReadRef
	3: Ret
}

public create_supply<Ty0: drop>(Arg0: Ty0): Supply<Ty0> {
B0:
	0: LdU64(0)
	1: PackGeneric[0](Supply<Ty0>)
	2: Ret
}

public increase_supply<Ty0>(Arg0: &mut Supply<Ty0>, Arg1: u64): Balance<Ty0> {
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdU64(18446744073709551615)
	2: CopyLoc[0](Arg0: &mut Supply<Ty0>)
	3: ImmBorrowFieldGeneric[1](Supply.value: u64)
	4: ReadRef
	5: Sub
	6: Lt
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut Supply<Ty0>)
	10: Pop
	11: LdConst[1](u64: 1)
	12: Abort
B3:
	13: CopyLoc[0](Arg0: &mut Supply<Ty0>)
	14: ImmBorrowFieldGeneric[1](Supply.value: u64)
	15: ReadRef
	16: CopyLoc[1](Arg1: u64)
	17: Add
	18: MoveLoc[0](Arg0: &mut Supply<Ty0>)
	19: MutBorrowFieldGeneric[1](Supply.value: u64)
	20: WriteRef
	21: MoveLoc[1](Arg1: u64)
	22: PackGeneric[1](Balance<Ty0>)
	23: Ret
}

public decrease_supply<Ty0>(Arg0: &mut Supply<Ty0>, Arg1: Balance<Ty0>): u64 {
L2:	loc0: u64
B0:
	0: MoveLoc[1](Arg1: Balance<Ty0>)
	1: UnpackGeneric[1](Balance<Ty0>)
	2: StLoc[2](loc0: u64)
	3: CopyLoc[0](Arg0: &mut Supply<Ty0>)
	4: ImmBorrowFieldGeneric[1](Supply.value: u64)
	5: ReadRef
	6: CopyLoc[2](loc0: u64)
	7: Ge
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[0](Arg0: &mut Supply<Ty0>)
	11: Pop
	12: LdConst[1](u64: 1)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Supply<Ty0>)
	15: ImmBorrowFieldGeneric[1](Supply.value: u64)
	16: ReadRef
	17: CopyLoc[2](loc0: u64)
	18: Sub
	19: MoveLoc[0](Arg0: &mut Supply<Ty0>)
	20: MutBorrowFieldGeneric[1](Supply.value: u64)
	21: WriteRef
	22: MoveLoc[2](loc0: u64)
	23: Ret
}

public zero<Ty0>(): Balance<Ty0> {
B0:
	0: LdU64(0)
	1: PackGeneric[1](Balance<Ty0>)
	2: Ret
}

public join<Ty0>(Arg0: &mut Balance<Ty0>, Arg1: Balance<Ty0>): u64 {
L2:	loc0: u64
B0:
	0: MoveLoc[1](Arg1: Balance<Ty0>)
	1: UnpackGeneric[1](Balance<Ty0>)
	2: StLoc[2](loc0: u64)
	3: CopyLoc[0](Arg0: &mut Balance<Ty0>)
	4: ImmBorrowFieldGeneric[0](Balance.value: u64)
	5: ReadRef
	6: MoveLoc[2](loc0: u64)
	7: Add
	8: CopyLoc[0](Arg0: &mut Balance<Ty0>)
	9: MutBorrowFieldGeneric[0](Balance.value: u64)
	10: WriteRef
	11: MoveLoc[0](Arg0: &mut Balance<Ty0>)
	12: ImmBorrowFieldGeneric[0](Balance.value: u64)
	13: ReadRef
	14: Ret
}

public split<Ty0>(Arg0: &mut Balance<Ty0>, Arg1: u64): Balance<Ty0> {
B0:
	0: CopyLoc[0](Arg0: &mut Balance<Ty0>)
	1: ImmBorrowFieldGeneric[0](Balance.value: u64)
	2: ReadRef
	3: CopyLoc[1](Arg1: u64)
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut Balance<Ty0>)
	8: Pop
	9: LdConst[2](u64: 2)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut Balance<Ty0>)
	12: ImmBorrowFieldGeneric[0](Balance.value: u64)
	13: ReadRef
	14: CopyLoc[1](Arg1: u64)
	15: Sub
	16: MoveLoc[0](Arg0: &mut Balance<Ty0>)
	17: MutBorrowFieldGeneric[0](Balance.value: u64)
	18: WriteRef
	19: MoveLoc[1](Arg1: u64)
	20: PackGeneric[1](Balance<Ty0>)
	21: Ret
}

public withdraw_all<Ty0>(Arg0: &mut Balance<Ty0>): Balance<Ty0> {
L1:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut Balance<Ty0>)
	1: ImmBorrowFieldGeneric[0](Balance.value: u64)
	2: ReadRef
	3: StLoc[1](loc0: u64)
	4: MoveLoc[0](Arg0: &mut Balance<Ty0>)
	5: MoveLoc[1](loc0: u64)
	6: Call split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	7: Ret
}

public destroy_zero<Ty0>(Arg0: Balance<Ty0>) {
B0:
	0: ImmBorrowLoc[0](Arg0: Balance<Ty0>)
	1: ImmBorrowFieldGeneric[0](Balance.value: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: Balance<Ty0>)
	10: UnpackGeneric[1](Balance<Ty0>)
	11: Pop
	12: Ret
}

create_staking_rewards<Ty0>(Arg0: u64, Arg1: &TxContext): Balance<Ty0> {
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[6](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[3](u64: 3)
	7: Abort
B3:
	8: Call type_name::get<Ty0>(): TypeName
	9: Call type_name::into_string(TypeName): String
	10: Call ascii::into_bytes(String): vector<u8>
	11: LdConst[5](vector<u8>: "000..)
	12: Eq
	13: BrFalse(15)
B4:
	14: Branch(17)
B5:
	15: LdConst[4](u64: 4)
	16: Abort
B6:
	17: MoveLoc[0](Arg0: u64)
	18: PackGeneric[1](Balance<Ty0>)
	19: Ret
}

destroy_storage_rebates<Ty0>(Arg0: Balance<Ty0>, Arg1: &TxContext) {
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[6](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[3](u64: 3)
	7: Abort
B3:
	8: Call type_name::get<Ty0>(): TypeName
	9: Call type_name::into_string(TypeName): String
	10: Call ascii::into_bytes(String): vector<u8>
	11: LdConst[5](vector<u8>: "000..)
	12: Eq
	13: BrFalse(15)
B4:
	14: Branch(17)
B5:
	15: LdConst[4](u64: 4)
	16: Abort
B6:
	17: MoveLoc[0](Arg0: Balance<Ty0>)
	18: UnpackGeneric[1](Balance<Ty0>)
	19: Pop
	20: Ret
}

public(friend) destroy_supply<Ty0>(Arg0: Supply<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: Supply<Ty0>)
	1: UnpackGeneric[0](Supply<Ty0>)
	2: Ret
}

send_to_account<Ty0>(Arg0: Balance<Ty0>, Arg1: address) {
L2:	loc0: u64
B0:
	0: MoveLoc[0](Arg0: Balance<Ty0>)
	1: UnpackGeneric[1](Balance<Ty0>)
	2: StLoc[2](loc0: u64)
	3: CopyLoc[1](Arg1: address)
	4: Call accumulator::accumulator_address<Balance<Ty0>>(address): address
	5: MoveLoc[1](Arg1: address)
	6: MoveLoc[2](loc0: u64)
	7: Call accumulator::emit_deposit_event<Balance<Ty0>>(address, address, u64)
	8: Ret
}

withdraw_from_account<Ty0>(Arg0: u64, Arg1: &TxContext): Balance<Ty0> {
L2:	loc0: address
L3:	loc1: Balance<Ty0>
L4:	loc2: address
B0:
	0: MoveLoc[1](Arg1: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: StLoc[4](loc2: address)
	3: CopyLoc[4](loc2: address)
	4: Call accumulator::accumulator_address<Balance<Ty0>>(address): address
	5: StLoc[2](loc0: address)
	6: CopyLoc[0](Arg0: u64)
	7: PackGeneric[1](Balance<Ty0>)
	8: StLoc[3](loc1: Balance<Ty0>)
	9: MoveLoc[2](loc0: address)
	10: MoveLoc[4](loc2: address)
	11: MoveLoc[0](Arg0: u64)
	12: Call accumulator::emit_withdraw_event<Balance<Ty0>>(address, address, u64)
	13: MoveLoc[3](loc1: Balance<Ty0>)
	14: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => vector<u8>: "0000000000000000000000000000000000000000000000000000000000000002::safe::SAFE" // interpreted as UTF8 string
	6 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 2.bcs {
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000001::bcs as 1bcs;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct BCS has copy, drop, store {
	bytes: vector<u8>
}

public to_bytes<Ty0>(Arg0: &Ty0): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Ty0)
	1: Call 1bcs::to_bytes<Ty0>(&Ty0): vector<u8>
	2: Ret
}

public new(Arg0: vector<u8>): BCS {
B0:
	0: MutBorrowLoc[0](Arg0: vector<u8>)
	1: Call vector::reverse<u8>(&mut vector<u8>)
	2: MoveLoc[0](Arg0: vector<u8>)
	3: Pack[0](BCS)
	4: Ret
}

public into_remainder_bytes(Arg0: BCS): vector<u8> {
L1:	loc0: vector<u8>
B0:
	0: MoveLoc[0](Arg0: BCS)
	1: Unpack[0](BCS)
	2: StLoc[1](loc0: vector<u8>)
	3: MutBorrowLoc[1](loc0: vector<u8>)
	4: Call vector::reverse<u8>(&mut vector<u8>)
	5: MoveLoc[1](loc0: vector<u8>)
	6: Ret
}

public peel_address(Arg0: &mut BCS): address {
L1:	loc0: u64
L2:	loc1: u8
L3:	loc2: &mut vector<u8>
L4:	loc3: u64
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: vector<u8>
B0:
	0: CopyLoc[0](Arg0: &mut BCS)
	1: ImmBorrowField[0](BCS.bytes: vector<u8>)
	2: VecLen(6)
	3: Call address::length(): u64
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut BCS)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: LdConst[3](vector<u8>: "" /..)
	12: StLoc[7](loc6: vector<u8>)
	13: Call address::length(): u64
	14: StLoc[1](loc0: u64)
	15: LdU64(0)
	16: StLoc[5](loc4: u64)
	17: MoveLoc[1](loc0: u64)
	18: StLoc[6](loc5: u64)
B4:
	19: CopyLoc[5](loc4: u64)
	20: CopyLoc[6](loc5: u64)
	21: Lt
	22: BrFalse(41)
B5:
	23: CopyLoc[5](loc4: u64)
	24: StLoc[4](loc3: u64)
	25: MutBorrowLoc[7](loc6: vector<u8>)
	26: StLoc[3](loc2: &mut vector<u8>)
	27: MoveLoc[4](loc3: u64)
	28: Pop
	29: CopyLoc[0](Arg0: &mut BCS)
	30: MutBorrowField[0](BCS.bytes: vector<u8>)
	31: VecPopBack(6)
	32: StLoc[2](loc1: u8)
	33: MoveLoc[3](loc2: &mut vector<u8>)
	34: MoveLoc[2](loc1: u8)
	35: VecPushBack(6)
	36: MoveLoc[5](loc4: u64)
	37: LdU64(1)
	38: Add
	39: StLoc[5](loc4: u64)
	40: Branch(19)
B6:
	41: MoveLoc[0](Arg0: &mut BCS)
	42: Pop
	43: MoveLoc[7](loc6: vector<u8>)
	44: Call address::from_bytes(vector<u8>): address
	45: Ret
}

public peel_bool(Arg0: &mut BCS): bool {
L1:	loc0: bool
L2:	loc1: u8
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: Call peel_u8(&mut BCS): u8
	2: StLoc[2](loc1: u8)
	3: CopyLoc[2](loc1: u8)
	4: LdU8(0)
	5: Eq
	6: BrFalse(10)
B1:
	7: LdFalse
	8: StLoc[1](loc0: bool)
	9: Branch(19)
B2:
	10: MoveLoc[2](loc1: u8)
	11: LdU8(1)
	12: Eq
	13: BrFalse(15)
B3:
	14: Branch(17)
B4:
	15: LdConst[1](u64: 1)
	16: Abort
B5:
	17: LdTrue
	18: StLoc[1](loc0: bool)
B6:
	19: MoveLoc[1](loc0: bool)
	20: Ret
}

public peel_u8(Arg0: &mut BCS): u8 {
B0:
	0: CopyLoc[0](Arg0: &mut BCS)
	1: ImmBorrowField[0](BCS.bytes: vector<u8>)
	2: VecLen(6)
	3: LdU64(1)
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut BCS)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut BCS)
	12: MutBorrowField[0](BCS.bytes: vector<u8>)
	13: VecPopBack(6)
	14: Ret
}

public peel_u16(Arg0: &mut BCS): u16 {
L1:	loc0: &mut BCS
L2:	loc1: u16
L3:	loc2: u8
L4:	loc3: u16
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[1](loc0: &mut BCS)
	2: CopyLoc[1](loc0: &mut BCS)
	3: ImmBorrowField[0](BCS.bytes: vector<u8>)
	4: VecLen(6)
	5: LdU64(2)
	6: Ge
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](loc0: &mut BCS)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: LdU16(0)
	14: StLoc[4](loc3: u16)
	15: LdU8(0)
	16: StLoc[3](loc2: u8)
B4:
	17: CopyLoc[3](loc2: u8)
	18: LdU8(16)
	19: Lt
	20: BrFalse(38)
B5:
	21: CopyLoc[1](loc0: &mut BCS)
	22: MutBorrowField[0](BCS.bytes: vector<u8>)
	23: VecPopBack(6)
	24: CastU16
	25: StLoc[2](loc1: u16)
	26: MoveLoc[4](loc3: u16)
	27: MoveLoc[2](loc1: u16)
	28: CopyLoc[3](loc2: u8)
	29: CastU8
	30: Shl
	31: Add
	32: StLoc[4](loc3: u16)
	33: MoveLoc[3](loc2: u8)
	34: LdU8(8)
	35: Add
	36: StLoc[3](loc2: u8)
	37: Branch(17)
B6:
	38: MoveLoc[1](loc0: &mut BCS)
	39: Pop
	40: MoveLoc[4](loc3: u16)
	41: Ret
}

public peel_u32(Arg0: &mut BCS): u32 {
L1:	loc0: &mut BCS
L2:	loc1: u32
L3:	loc2: u8
L4:	loc3: u32
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[1](loc0: &mut BCS)
	2: CopyLoc[1](loc0: &mut BCS)
	3: ImmBorrowField[0](BCS.bytes: vector<u8>)
	4: VecLen(6)
	5: LdU64(4)
	6: Ge
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](loc0: &mut BCS)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: LdU32(0)
	14: StLoc[4](loc3: u32)
	15: LdU8(0)
	16: StLoc[3](loc2: u8)
B4:
	17: CopyLoc[3](loc2: u8)
	18: LdU8(32)
	19: Lt
	20: BrFalse(38)
B5:
	21: CopyLoc[1](loc0: &mut BCS)
	22: MutBorrowField[0](BCS.bytes: vector<u8>)
	23: VecPopBack(6)
	24: CastU32
	25: StLoc[2](loc1: u32)
	26: MoveLoc[4](loc3: u32)
	27: MoveLoc[2](loc1: u32)
	28: CopyLoc[3](loc2: u8)
	29: CastU8
	30: Shl
	31: Add
	32: StLoc[4](loc3: u32)
	33: MoveLoc[3](loc2: u8)
	34: LdU8(8)
	35: Add
	36: StLoc[3](loc2: u8)
	37: Branch(17)
B6:
	38: MoveLoc[1](loc0: &mut BCS)
	39: Pop
	40: MoveLoc[4](loc3: u32)
	41: Ret
}

public peel_u64(Arg0: &mut BCS): u64 {
L1:	loc0: &mut BCS
L2:	loc1: u64
L3:	loc2: u8
L4:	loc3: u64
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[1](loc0: &mut BCS)
	2: CopyLoc[1](loc0: &mut BCS)
	3: ImmBorrowField[0](BCS.bytes: vector<u8>)
	4: VecLen(6)
	5: LdU64(8)
	6: Ge
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](loc0: &mut BCS)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: LdU64(0)
	14: StLoc[4](loc3: u64)
	15: LdU8(0)
	16: StLoc[3](loc2: u8)
B4:
	17: CopyLoc[3](loc2: u8)
	18: LdU8(64)
	19: Lt
	20: BrFalse(38)
B5:
	21: CopyLoc[1](loc0: &mut BCS)
	22: MutBorrowField[0](BCS.bytes: vector<u8>)
	23: VecPopBack(6)
	24: CastU64
	25: StLoc[2](loc1: u64)
	26: MoveLoc[4](loc3: u64)
	27: MoveLoc[2](loc1: u64)
	28: CopyLoc[3](loc2: u8)
	29: CastU8
	30: Shl
	31: Add
	32: StLoc[4](loc3: u64)
	33: MoveLoc[3](loc2: u8)
	34: LdU8(8)
	35: Add
	36: StLoc[3](loc2: u8)
	37: Branch(17)
B6:
	38: MoveLoc[1](loc0: &mut BCS)
	39: Pop
	40: MoveLoc[4](loc3: u64)
	41: Ret
}

public peel_u128(Arg0: &mut BCS): u128 {
L1:	loc0: &mut BCS
L2:	loc1: u128
L3:	loc2: u8
L4:	loc3: u128
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[1](loc0: &mut BCS)
	2: CopyLoc[1](loc0: &mut BCS)
	3: ImmBorrowField[0](BCS.bytes: vector<u8>)
	4: VecLen(6)
	5: LdU64(16)
	6: Ge
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](loc0: &mut BCS)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: LdU128(0)
	14: StLoc[4](loc3: u128)
	15: LdU8(0)
	16: StLoc[3](loc2: u8)
B4:
	17: CopyLoc[3](loc2: u8)
	18: LdU8(128)
	19: Lt
	20: BrFalse(38)
B5:
	21: CopyLoc[1](loc0: &mut BCS)
	22: MutBorrowField[0](BCS.bytes: vector<u8>)
	23: VecPopBack(6)
	24: CastU128
	25: StLoc[2](loc1: u128)
	26: MoveLoc[4](loc3: u128)
	27: MoveLoc[2](loc1: u128)
	28: CopyLoc[3](loc2: u8)
	29: CastU8
	30: Shl
	31: Add
	32: StLoc[4](loc3: u128)
	33: MoveLoc[3](loc2: u8)
	34: LdU8(8)
	35: Add
	36: StLoc[3](loc2: u8)
	37: Branch(17)
B6:
	38: MoveLoc[1](loc0: &mut BCS)
	39: Pop
	40: MoveLoc[4](loc3: u128)
	41: Ret
}

public peel_u256(Arg0: &mut BCS): u256 {
L1:	loc0: &mut BCS
L2:	loc1: u256
L3:	loc2: u16
L4:	loc3: u256
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[1](loc0: &mut BCS)
	2: CopyLoc[1](loc0: &mut BCS)
	3: ImmBorrowField[0](BCS.bytes: vector<u8>)
	4: VecLen(6)
	5: LdU64(32)
	6: Ge
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](loc0: &mut BCS)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: LdU256(0)
	14: StLoc[4](loc3: u256)
	15: LdU16(0)
	16: StLoc[3](loc2: u16)
B4:
	17: CopyLoc[3](loc2: u16)
	18: LdU16(256)
	19: Lt
	20: BrFalse(38)
B5:
	21: CopyLoc[1](loc0: &mut BCS)
	22: MutBorrowField[0](BCS.bytes: vector<u8>)
	23: VecPopBack(6)
	24: CastU256
	25: StLoc[2](loc1: u256)
	26: MoveLoc[4](loc3: u256)
	27: MoveLoc[2](loc1: u256)
	28: CopyLoc[3](loc2: u16)
	29: CastU8
	30: Shl
	31: Add
	32: StLoc[4](loc3: u256)
	33: MoveLoc[3](loc2: u16)
	34: LdU16(8)
	35: Add
	36: StLoc[3](loc2: u16)
	37: Branch(17)
B6:
	38: MoveLoc[1](loc0: &mut BCS)
	39: Pop
	40: MoveLoc[4](loc3: u256)
	41: Ret
}

public peel_vec_length(Arg0: &mut BCS): u64 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: u8
L4:	loc3: u64
B0:
	0: LdU64(0)
	1: LdU8(0)
	2: LdU64(0)
	3: StLoc[2](loc1: u64)
	4: StLoc[3](loc2: u8)
	5: StLoc[4](loc3: u64)
B1:
	6: CopyLoc[2](loc1: u64)
	7: LdU64(4)
	8: Le
	9: BrFalse(11)
B2:
	10: Branch(15)
B3:
	11: MoveLoc[0](Arg0: &mut BCS)
	12: Pop
	13: LdConst[2](u64: 2)
	14: Abort
B4:
	15: CopyLoc[0](Arg0: &mut BCS)
	16: MutBorrowField[0](BCS.bytes: vector<u8>)
	17: VecPopBack(6)
	18: CastU64
	19: StLoc[1](loc0: u64)
	20: MoveLoc[2](loc1: u64)
	21: LdU64(1)
	22: Add
	23: StLoc[2](loc1: u64)
	24: MoveLoc[4](loc3: u64)
	25: CopyLoc[1](loc0: u64)
	26: LdU64(127)
	27: BitAnd
	28: CopyLoc[3](loc2: u8)
	29: Shl
	30: BitOr
	31: StLoc[4](loc3: u64)
	32: MoveLoc[1](loc0: u64)
	33: LdU64(128)
	34: BitAnd
	35: LdU64(0)
	36: Eq
	37: BrFalse(39)
B5:
	38: Branch(44)
B6:
	39: MoveLoc[3](loc2: u8)
	40: LdU8(7)
	41: Add
	42: StLoc[3](loc2: u8)
	43: Branch(6)
B7:
	44: MoveLoc[0](Arg0: &mut BCS)
	45: Pop
	46: MoveLoc[4](loc3: u64)
	47: Ret
}

public peel_vec_address(Arg0: &mut BCS): vector<address> {
L1:	loc0: u64
L2:	loc1: address
L3:	loc2: &mut vector<address>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<address>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[4](vector<address>: 00)
	3: StLoc[8](loc7: vector<address>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<address>)
	18: StLoc[3](loc2: &mut vector<address>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_address(&mut BCS): address
	23: StLoc[2](loc1: address)
	24: MoveLoc[3](loc2: &mut vector<address>)
	25: MoveLoc[2](loc1: address)
	26: VecPushBack(4)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<address>)
	35: Ret
}

public peel_vec_bool(Arg0: &mut BCS): vector<bool> {
L1:	loc0: u64
L2:	loc1: bool
L3:	loc2: &mut vector<bool>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<bool>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[5](vector<bool>: 00)
	3: StLoc[8](loc7: vector<bool>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<bool>)
	18: StLoc[3](loc2: &mut vector<bool>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_bool(&mut BCS): bool
	23: StLoc[2](loc1: bool)
	24: MoveLoc[3](loc2: &mut vector<bool>)
	25: MoveLoc[2](loc1: bool)
	26: VecPushBack(5)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<bool>)
	35: Ret
}

public peel_vec_u8(Arg0: &mut BCS): vector<u8> {
L1:	loc0: u64
L2:	loc1: u8
L3:	loc2: &mut vector<u8>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<u8>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[3](vector<u8>: "" /..)
	3: StLoc[8](loc7: vector<u8>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<u8>)
	18: StLoc[3](loc2: &mut vector<u8>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_u8(&mut BCS): u8
	23: StLoc[2](loc1: u8)
	24: MoveLoc[3](loc2: &mut vector<u8>)
	25: MoveLoc[2](loc1: u8)
	26: VecPushBack(6)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<u8>)
	35: Ret
}

public peel_vec_vec_u8(Arg0: &mut BCS): vector<vector<u8>> {
L1:	loc0: u64
L2:	loc1: vector<u8>
L3:	loc2: &mut vector<vector<u8>>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<vector<u8>>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[6](vector<vector<u8>>: 00)
	3: StLoc[8](loc7: vector<vector<u8>>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<vector<u8>>)
	18: StLoc[3](loc2: &mut vector<vector<u8>>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_vec_u8(&mut BCS): vector<u8>
	23: StLoc[2](loc1: vector<u8>)
	24: MoveLoc[3](loc2: &mut vector<vector<u8>>)
	25: MoveLoc[2](loc1: vector<u8>)
	26: VecPushBack(1)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<vector<u8>>)
	35: Ret
}

public peel_vec_u16(Arg0: &mut BCS): vector<u16> {
L1:	loc0: u64
L2:	loc1: u16
L3:	loc2: &mut vector<u16>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<u16>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[7](vector<u16>: 00)
	3: StLoc[8](loc7: vector<u16>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<u16>)
	18: StLoc[3](loc2: &mut vector<u16>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_u16(&mut BCS): u16
	23: StLoc[2](loc1: u16)
	24: MoveLoc[3](loc2: &mut vector<u16>)
	25: MoveLoc[2](loc1: u16)
	26: VecPushBack(7)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<u16>)
	35: Ret
}

public peel_vec_u32(Arg0: &mut BCS): vector<u32> {
L1:	loc0: u64
L2:	loc1: u32
L3:	loc2: &mut vector<u32>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<u32>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[8](vector<u32>: 00)
	3: StLoc[8](loc7: vector<u32>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<u32>)
	18: StLoc[3](loc2: &mut vector<u32>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_u32(&mut BCS): u32
	23: StLoc[2](loc1: u32)
	24: MoveLoc[3](loc2: &mut vector<u32>)
	25: MoveLoc[2](loc1: u32)
	26: VecPushBack(8)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<u32>)
	35: Ret
}

public peel_vec_u64(Arg0: &mut BCS): vector<u64> {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: &mut vector<u64>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<u64>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[9](vector<u64>: 00)
	3: StLoc[8](loc7: vector<u64>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<u64>)
	18: StLoc[3](loc2: &mut vector<u64>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_u64(&mut BCS): u64
	23: StLoc[2](loc1: u64)
	24: MoveLoc[3](loc2: &mut vector<u64>)
	25: MoveLoc[2](loc1: u64)
	26: VecPushBack(9)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<u64>)
	35: Ret
}

public peel_vec_u128(Arg0: &mut BCS): vector<u128> {
L1:	loc0: u64
L2:	loc1: u128
L3:	loc2: &mut vector<u128>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<u128>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[10](vector<u128>: 00)
	3: StLoc[8](loc7: vector<u128>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<u128>)
	18: StLoc[3](loc2: &mut vector<u128>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_u128(&mut BCS): u128
	23: StLoc[2](loc1: u128)
	24: MoveLoc[3](loc2: &mut vector<u128>)
	25: MoveLoc[2](loc1: u128)
	26: VecPushBack(10)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<u128>)
	35: Ret
}

public peel_vec_u256(Arg0: &mut BCS): vector<u256> {
L1:	loc0: u64
L2:	loc1: u256
L3:	loc2: &mut vector<u256>
L4:	loc3: &mut BCS
L5:	loc4: u64
L6:	loc5: u64
L7:	loc6: u64
L8:	loc7: vector<u256>
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[4](loc3: &mut BCS)
	2: LdConst[11](vector<u256>: 00)
	3: StLoc[8](loc7: vector<u256>)
	4: CopyLoc[4](loc3: &mut BCS)
	5: Call peel_vec_length(&mut BCS): u64
	6: StLoc[1](loc0: u64)
	7: LdU64(0)
	8: StLoc[5](loc4: u64)
	9: MoveLoc[1](loc0: u64)
	10: StLoc[7](loc6: u64)
B1:
	11: CopyLoc[5](loc4: u64)
	12: CopyLoc[7](loc6: u64)
	13: Lt
	14: BrFalse(32)
B2:
	15: CopyLoc[5](loc4: u64)
	16: StLoc[6](loc5: u64)
	17: MutBorrowLoc[8](loc7: vector<u256>)
	18: StLoc[3](loc2: &mut vector<u256>)
	19: MoveLoc[6](loc5: u64)
	20: Pop
	21: CopyLoc[4](loc3: &mut BCS)
	22: Call peel_u256(&mut BCS): u256
	23: StLoc[2](loc1: u256)
	24: MoveLoc[3](loc2: &mut vector<u256>)
	25: MoveLoc[2](loc1: u256)
	26: VecPushBack(11)
	27: MoveLoc[5](loc4: u64)
	28: LdU64(1)
	29: Add
	30: StLoc[5](loc4: u64)
	31: Branch(11)
B3:
	32: MoveLoc[4](loc3: &mut BCS)
	33: Pop
	34: MoveLoc[8](loc7: vector<u256>)
	35: Ret
}

public peel_enum_tag(Arg0: &mut BCS): u32 {
L1:	loc0: u64
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: Call peel_vec_length(&mut BCS): u64
	2: StLoc[1](loc0: u64)
	3: CopyLoc[1](loc0: u64)
	4: LdU64(4294967295)
	5: Le
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: MoveLoc[1](loc0: u64)
	11: CastU32
	12: Ret
}

public peel_option_address(Arg0: &mut BCS): Option<address> {
L1:	loc0: Option<address>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_address(&mut BCS): address
	7: Call option::some<address>(address): Option<address>
	8: StLoc[1](loc0: Option<address>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<address>(): Option<address>
	13: StLoc[1](loc0: Option<address>)
B3:
	14: MoveLoc[1](loc0: Option<address>)
	15: Ret
}

public peel_option_bool(Arg0: &mut BCS): Option<bool> {
L1:	loc0: Option<bool>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_bool(&mut BCS): bool
	7: Call option::some<bool>(bool): Option<bool>
	8: StLoc[1](loc0: Option<bool>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<bool>(): Option<bool>
	13: StLoc[1](loc0: Option<bool>)
B3:
	14: MoveLoc[1](loc0: Option<bool>)
	15: Ret
}

public peel_option_u8(Arg0: &mut BCS): Option<u8> {
L1:	loc0: Option<u8>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_u8(&mut BCS): u8
	7: Call option::some<u8>(u8): Option<u8>
	8: StLoc[1](loc0: Option<u8>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<u8>(): Option<u8>
	13: StLoc[1](loc0: Option<u8>)
B3:
	14: MoveLoc[1](loc0: Option<u8>)
	15: Ret
}

public peel_option_u16(Arg0: &mut BCS): Option<u16> {
L1:	loc0: Option<u16>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_u16(&mut BCS): u16
	7: Call option::some<u16>(u16): Option<u16>
	8: StLoc[1](loc0: Option<u16>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<u16>(): Option<u16>
	13: StLoc[1](loc0: Option<u16>)
B3:
	14: MoveLoc[1](loc0: Option<u16>)
	15: Ret
}

public peel_option_u32(Arg0: &mut BCS): Option<u32> {
L1:	loc0: Option<u32>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_u32(&mut BCS): u32
	7: Call option::some<u32>(u32): Option<u32>
	8: StLoc[1](loc0: Option<u32>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<u32>(): Option<u32>
	13: StLoc[1](loc0: Option<u32>)
B3:
	14: MoveLoc[1](loc0: Option<u32>)
	15: Ret
}

public peel_option_u64(Arg0: &mut BCS): Option<u64> {
L1:	loc0: Option<u64>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_u64(&mut BCS): u64
	7: Call option::some<u64>(u64): Option<u64>
	8: StLoc[1](loc0: Option<u64>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<u64>(): Option<u64>
	13: StLoc[1](loc0: Option<u64>)
B3:
	14: MoveLoc[1](loc0: Option<u64>)
	15: Ret
}

public peel_option_u128(Arg0: &mut BCS): Option<u128> {
L1:	loc0: Option<u128>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_u128(&mut BCS): u128
	7: Call option::some<u128>(u128): Option<u128>
	8: StLoc[1](loc0: Option<u128>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<u128>(): Option<u128>
	13: StLoc[1](loc0: Option<u128>)
B3:
	14: MoveLoc[1](loc0: Option<u128>)
	15: Ret
}

public peel_option_u256(Arg0: &mut BCS): Option<u256> {
L1:	loc0: Option<u256>
L2:	loc1: &mut BCS
B0:
	0: MoveLoc[0](Arg0: &mut BCS)
	1: StLoc[2](loc1: &mut BCS)
	2: CopyLoc[2](loc1: &mut BCS)
	3: Call peel_bool(&mut BCS): bool
	4: BrFalse(10)
B1:
	5: MoveLoc[2](loc1: &mut BCS)
	6: Call peel_u256(&mut BCS): u256
	7: Call option::some<u256>(u256): Option<u256>
	8: StLoc[1](loc0: Option<u256>)
	9: Branch(14)
B2:
	10: MoveLoc[2](loc1: &mut BCS)
	11: Pop
	12: Call option::none<u256>(): Option<u256>
	13: StLoc[1](loc0: Option<u256>)
B3:
	14: MoveLoc[1](loc0: Option<u256>)
	15: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => vector<u8>: "" // interpreted as UTF8 string
	4 => vector<address>: 00
	5 => vector<bool>: 00
	6 => vector<vector<u8>>: 00
	7 => vector<u16>: 00
	8 => vector<u32>: 00
	9 => vector<u64>: 00
	10 => vector<u128>: 00
	11 => vector<u256>: 00
]
}

// Move bytecode v6
module 2.bls12381 {
use 0000000000000000000000000000000000000000000000000000000000000002::group_ops;

struct Scalar {
	dummy_field: bool
}

struct G1 {
	dummy_field: bool
}

struct G2 {
	dummy_field: bool
}

struct GT {
	dummy_field: bool
}

struct UncompressedG1 {
	dummy_field: bool
}

native public bls12381_min_sig_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>): bool;

native public bls12381_min_pk_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>): bool;

public scalar_from_bytes(Arg0: &vector<u8>): Element<Scalar> {
B0:
	0: LdConst[8](u8: 0)
	1: MoveLoc[0](Arg0: &vector<u8>)
	2: LdFalse
	3: Call group_ops::from_bytes<Scalar>(u8, &vector<u8>, bool): Element<Scalar>
	4: Ret
}

public scalar_from_u64(Arg0: u64): Element<Scalar> {
L1:	loc0: vector<u8>
B0:
	0: LdConst[0](vector<u8>: "..)
	1: StLoc[1](loc0: vector<u8>)
	2: MoveLoc[0](Arg0: u64)
	3: LdTrue
	4: MutBorrowLoc[1](loc0: vector<u8>)
	5: Call group_ops::set_as_prefix(u64, bool, &mut vector<u8>)
	6: LdConst[8](u8: 0)
	7: ImmBorrowLoc[1](loc0: vector<u8>)
	8: LdTrue
	9: Call group_ops::from_bytes<Scalar>(u8, &vector<u8>, bool): Element<Scalar>
	10: Ret
}

public scalar_zero(): Element<Scalar> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[0](vector<u8>: "..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[8](u8: 0)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<Scalar>(u8, &vector<u8>, bool): Element<Scalar>
	6: Ret
}

public scalar_one(): Element<Scalar> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[1](vector<u8>: "..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[8](u8: 0)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<Scalar>(u8, &vector<u8>, bool): Element<Scalar>
	6: Ret
}

public scalar_add(Arg0: &Element<Scalar>, Arg1: &Element<Scalar>): Element<Scalar> {
B0:
	0: LdConst[8](u8: 0)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<Scalar>)
	3: Call group_ops::add<Scalar>(u8, &Element<Scalar>, &Element<Scalar>): Element<Scalar>
	4: Ret
}

public scalar_sub(Arg0: &Element<Scalar>, Arg1: &Element<Scalar>): Element<Scalar> {
B0:
	0: LdConst[8](u8: 0)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<Scalar>)
	3: Call group_ops::sub<Scalar>(u8, &Element<Scalar>, &Element<Scalar>): Element<Scalar>
	4: Ret
}

public scalar_mul(Arg0: &Element<Scalar>, Arg1: &Element<Scalar>): Element<Scalar> {
B0:
	0: LdConst[8](u8: 0)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<Scalar>)
	3: Call group_ops::mul<Scalar, Scalar>(u8, &Element<Scalar>, &Element<Scalar>): Element<Scalar>
	4: Ret
}

public scalar_div(Arg0: &Element<Scalar>, Arg1: &Element<Scalar>): Element<Scalar> {
B0:
	0: LdConst[8](u8: 0)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<Scalar>)
	3: Call group_ops::div<Scalar, Scalar>(u8, &Element<Scalar>, &Element<Scalar>): Element<Scalar>
	4: Ret
}

public scalar_neg(Arg0: &Element<Scalar>): Element<Scalar> {
L1:	loc0: Element<Scalar>
B0:
	0: Call scalar_zero(): Element<Scalar>
	1: StLoc[1](loc0: Element<Scalar>)
	2: ImmBorrowLoc[1](loc0: Element<Scalar>)
	3: MoveLoc[0](Arg0: &Element<Scalar>)
	4: Call scalar_sub(&Element<Scalar>, &Element<Scalar>): Element<Scalar>
	5: Ret
}

public scalar_inv(Arg0: &Element<Scalar>): Element<Scalar> {
L1:	loc0: Element<Scalar>
L2:	loc1: &Element<Scalar>
B0:
	0: MoveLoc[0](Arg0: &Element<Scalar>)
	1: StLoc[2](loc1: &Element<Scalar>)
	2: Call scalar_one(): Element<Scalar>
	3: StLoc[1](loc0: Element<Scalar>)
	4: MoveLoc[2](loc1: &Element<Scalar>)
	5: ImmBorrowLoc[1](loc0: Element<Scalar>)
	6: Call scalar_div(&Element<Scalar>, &Element<Scalar>): Element<Scalar>
	7: Ret
}

public g1_from_bytes(Arg0: &vector<u8>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &vector<u8>)
	2: LdFalse
	3: Call group_ops::from_bytes<G1>(u8, &vector<u8>, bool): Element<G1>
	4: Ret
}

public g1_identity(): Element<G1> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[2](vector<u8>: 30c0..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[9](u8: 1)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<G1>(u8, &vector<u8>, bool): Element<G1>
	6: Ret
}

public g1_generator(): Element<G1> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[3](vector<u8>: 3097..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[9](u8: 1)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<G1>(u8, &vector<u8>, bool): Element<G1>
	6: Ret
}

public g1_add(Arg0: &Element<G1>, Arg1: &Element<G1>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &Element<G1>)
	2: MoveLoc[1](Arg1: &Element<G1>)
	3: Call group_ops::add<G1>(u8, &Element<G1>, &Element<G1>): Element<G1>
	4: Ret
}

public g1_sub(Arg0: &Element<G1>, Arg1: &Element<G1>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &Element<G1>)
	2: MoveLoc[1](Arg1: &Element<G1>)
	3: Call group_ops::sub<G1>(u8, &Element<G1>, &Element<G1>): Element<G1>
	4: Ret
}

public g1_mul(Arg0: &Element<Scalar>, Arg1: &Element<G1>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<G1>)
	3: Call group_ops::mul<Scalar, G1>(u8, &Element<Scalar>, &Element<G1>): Element<G1>
	4: Ret
}

public g1_div(Arg0: &Element<Scalar>, Arg1: &Element<G1>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<G1>)
	3: Call group_ops::div<Scalar, G1>(u8, &Element<Scalar>, &Element<G1>): Element<G1>
	4: Ret
}

public g1_neg(Arg0: &Element<G1>): Element<G1> {
L1:	loc0: Element<G1>
B0:
	0: Call g1_identity(): Element<G1>
	1: StLoc[1](loc0: Element<G1>)
	2: ImmBorrowLoc[1](loc0: Element<G1>)
	3: MoveLoc[0](Arg0: &Element<G1>)
	4: Call g1_sub(&Element<G1>, &Element<G1>): Element<G1>
	5: Ret
}

public hash_to_g1(Arg0: &vector<u8>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &vector<u8>)
	2: Call group_ops::hash_to<G1>(u8, &vector<u8>): Element<G1>
	3: Ret
}

public g1_multi_scalar_multiplication(Arg0: &vector<Element<Scalar>>, Arg1: &vector<Element<G1>>): Element<G1> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &vector<Element<Scalar>>)
	2: MoveLoc[1](Arg1: &vector<Element<G1>>)
	3: Call group_ops::multi_scalar_multiplication<Scalar, G1>(u8, &vector<Element<Scalar>>, &vector<Element<G1>>): Element<G1>
	4: Ret
}

public g1_to_uncompressed_g1(Arg0: &Element<G1>): Element<UncompressedG1> {
B0:
	0: LdConst[9](u8: 1)
	1: LdConst[12](u8: 4)
	2: MoveLoc[0](Arg0: &Element<G1>)
	3: Call group_ops::convert<G1, UncompressedG1>(u8, u8, &Element<G1>): Element<UncompressedG1>
	4: Ret
}

public g2_from_bytes(Arg0: &vector<u8>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &vector<u8>)
	2: LdFalse
	3: Call group_ops::from_bytes<G2>(u8, &vector<u8>, bool): Element<G2>
	4: Ret
}

public g2_identity(): Element<G2> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[4](vector<u8>: 60c0..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[10](u8: 2)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<G2>(u8, &vector<u8>, bool): Element<G2>
	6: Ret
}

public g2_generator(): Element<G2> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[5](vector<u8>: 6093..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[10](u8: 2)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<G2>(u8, &vector<u8>, bool): Element<G2>
	6: Ret
}

public g2_add(Arg0: &Element<G2>, Arg1: &Element<G2>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &Element<G2>)
	2: MoveLoc[1](Arg1: &Element<G2>)
	3: Call group_ops::add<G2>(u8, &Element<G2>, &Element<G2>): Element<G2>
	4: Ret
}

public g2_sub(Arg0: &Element<G2>, Arg1: &Element<G2>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &Element<G2>)
	2: MoveLoc[1](Arg1: &Element<G2>)
	3: Call group_ops::sub<G2>(u8, &Element<G2>, &Element<G2>): Element<G2>
	4: Ret
}

public g2_mul(Arg0: &Element<Scalar>, Arg1: &Element<G2>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<G2>)
	3: Call group_ops::mul<Scalar, G2>(u8, &Element<Scalar>, &Element<G2>): Element<G2>
	4: Ret
}

public g2_div(Arg0: &Element<Scalar>, Arg1: &Element<G2>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<G2>)
	3: Call group_ops::div<Scalar, G2>(u8, &Element<Scalar>, &Element<G2>): Element<G2>
	4: Ret
}

public g2_neg(Arg0: &Element<G2>): Element<G2> {
L1:	loc0: Element<G2>
B0:
	0: Call g2_identity(): Element<G2>
	1: StLoc[1](loc0: Element<G2>)
	2: ImmBorrowLoc[1](loc0: Element<G2>)
	3: MoveLoc[0](Arg0: &Element<G2>)
	4: Call g2_sub(&Element<G2>, &Element<G2>): Element<G2>
	5: Ret
}

public hash_to_g2(Arg0: &vector<u8>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &vector<u8>)
	2: Call group_ops::hash_to<G2>(u8, &vector<u8>): Element<G2>
	3: Ret
}

public g2_multi_scalar_multiplication(Arg0: &vector<Element<Scalar>>, Arg1: &vector<Element<G2>>): Element<G2> {
B0:
	0: LdConst[10](u8: 2)
	1: MoveLoc[0](Arg0: &vector<Element<Scalar>>)
	2: MoveLoc[1](Arg1: &vector<Element<G2>>)
	3: Call group_ops::multi_scalar_multiplication<Scalar, G2>(u8, &vector<Element<Scalar>>, &vector<Element<G2>>): Element<G2>
	4: Ret
}

public gt_identity(): Element<GT> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[6](vector<u8>: "..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[11](u8: 3)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<GT>(u8, &vector<u8>, bool): Element<GT>
	6: Ret
}

public gt_generator(): Element<GT> {
L0:	loc0: vector<u8>
B0:
	0: LdConst[7](vector<u8>: c004..)
	1: StLoc[0](loc0: vector<u8>)
	2: LdConst[11](u8: 3)
	3: ImmBorrowLoc[0](loc0: vector<u8>)
	4: LdTrue
	5: Call group_ops::from_bytes<GT>(u8, &vector<u8>, bool): Element<GT>
	6: Ret
}

public gt_add(Arg0: &Element<GT>, Arg1: &Element<GT>): Element<GT> {
B0:
	0: LdConst[11](u8: 3)
	1: MoveLoc[0](Arg0: &Element<GT>)
	2: MoveLoc[1](Arg1: &Element<GT>)
	3: Call group_ops::add<GT>(u8, &Element<GT>, &Element<GT>): Element<GT>
	4: Ret
}

public gt_sub(Arg0: &Element<GT>, Arg1: &Element<GT>): Element<GT> {
B0:
	0: LdConst[11](u8: 3)
	1: MoveLoc[0](Arg0: &Element<GT>)
	2: MoveLoc[1](Arg1: &Element<GT>)
	3: Call group_ops::sub<GT>(u8, &Element<GT>, &Element<GT>): Element<GT>
	4: Ret
}

public gt_mul(Arg0: &Element<Scalar>, Arg1: &Element<GT>): Element<GT> {
B0:
	0: LdConst[11](u8: 3)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<GT>)
	3: Call group_ops::mul<Scalar, GT>(u8, &Element<Scalar>, &Element<GT>): Element<GT>
	4: Ret
}

public gt_div(Arg0: &Element<Scalar>, Arg1: &Element<GT>): Element<GT> {
B0:
	0: LdConst[11](u8: 3)
	1: MoveLoc[0](Arg0: &Element<Scalar>)
	2: MoveLoc[1](Arg1: &Element<GT>)
	3: Call group_ops::div<Scalar, GT>(u8, &Element<Scalar>, &Element<GT>): Element<GT>
	4: Ret
}

public gt_neg(Arg0: &Element<GT>): Element<GT> {
L1:	loc0: Element<GT>
B0:
	0: Call gt_identity(): Element<GT>
	1: StLoc[1](loc0: Element<GT>)
	2: ImmBorrowLoc[1](loc0: Element<GT>)
	3: MoveLoc[0](Arg0: &Element<GT>)
	4: Call gt_sub(&Element<GT>, &Element<GT>): Element<GT>
	5: Ret
}

public pairing(Arg0: &Element<G1>, Arg1: &Element<G2>): Element<GT> {
B0:
	0: LdConst[9](u8: 1)
	1: MoveLoc[0](Arg0: &Element<G1>)
	2: MoveLoc[1](Arg1: &Element<G2>)
	3: Call group_ops::pairing<G1, G2, GT>(u8, &Element<G1>, &Element<G2>): Element<GT>
	4: Ret
}

public uncompressed_g1_to_g1(Arg0: &Element<UncompressedG1>): Element<G1> {
B0:
	0: LdConst[12](u8: 4)
	1: LdConst[9](u8: 1)
	2: MoveLoc[0](Arg0: &Element<UncompressedG1>)
	3: Call group_ops::convert<UncompressedG1, G1>(u8, u8, &Element<UncompressedG1>): Element<G1>
	4: Ret
}

public uncompressed_g1_sum(Arg0: &vector<Element<UncompressedG1>>): Element<UncompressedG1> {
B0:
	0: LdConst[12](u8: 4)
	1: MoveLoc[0](Arg0: &vector<Element<UncompressedG1>>)
	2: Call group_ops::sum<UncompressedG1>(u8, &vector<Element<UncompressedG1>>): Element<UncompressedG1>
	3: Ret
}

Constants [
	0 => vector<u8>: "" // interpreted as UTF8 string
	1 => vector<u8>: "
" // interpreted as UTF8 string
	2 => vector<u8>: 30c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
	3 => vector<u8>: 3097f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb
	4 => vector<u8>: 60c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
	5 => vector<u8>: 6093e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8
	6 => vector<u8>: "
" // interpreted as UTF8 string
	7 => vector<u8>: c0041250ebd871fc0a92a7b2d83168d0d727272d441befa15c503dd8e90ce98db3e7b6d194f60839c508a84305aaca1789b6089a1c5b46e5110b86750ec6a532348868a84045483c92b7af5af689452eafabf1a8943e50439f1d59882a98eaa0170f19f26337d205fb469cd6bd15c3d5a04dc88784fbb3d0b2dbdea54d43b2b73f2cbb12d58386a8703e0f948226e47ee89d06fba23eb7c5af0d9f80940ca771b6ffd5857baaf222eb95a7d2809d61bfe02e1bfd1b68ff02f0b8102ae1c2d5d5ab1a1368bb445c7c2d209703f239689ce34c0378a68e72a6b3b216da0e22a5031b54ddff57309396b38c881c4c849ec23e87193502b86edb8857c273fa075a50512937e0794e1e65a7617c90d8bd66065b1fffe51d7a579973b1315021ec3c19934f11b8b424cd48bf38fcef68083b0b0ec5c81a93b330ee1a677d0d15ff7b984e8978ef48881e32fac91b93b47333e2ba5703350f55a7aefcd3c31b4fcb6ce5771cc6a0e9786ab5973320c806ad360829107ba810c5a09ffdd9be2291a0c25a99a201b2f522473d171391125ba84dc4007cfbf2f8da752f7c74185203fcca589ac719c34dffbbaad8431dad1c1fb597aaa5018107154f25a764bd3c79937a45b84546da634b8f6be14a8061e55cceba478b23f7dacaa35c8ca78beae9624045b4b604c581234d086a9902249b64728ffd21a189e87935a954051c7cdba7b3872629a4fafc05066245cb9108f0242d0fe3ef0f41e58663bf08cf068672cbd01a7ec73baca4d72ca93544deff686bfd6df543d48eaa24afe47e1efde449383b676631
	8 => u8: 0
	9 => u8: 1
	10 => u8: 2
	11 => u8: 3
	12 => u8: 4
]
}

// Move bytecode v6
module 2.borrow {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct Referent<Ty0: store + key> has store {
	id: address,
	value: Option<Ty0>
}

struct Borrow {
	ref: address,
	obj: ID
}

public new<Ty0: store + key>(Arg0: Ty0, Arg1: &mut TxContext): Referent<Ty0> {
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call tx_context::fresh_object_address(&mut TxContext): address
	2: MoveLoc[0](Arg0: Ty0)
	3: Call option::some<Ty0>(Ty0): Option<Ty0>
	4: PackGeneric[0](Referent<Ty0>)
	5: Ret
}

public borrow<Ty0: store + key>(Arg0: &mut Referent<Ty0>): Ty0 * Borrow {
L1:	loc0: ID
L2:	loc1: Ty0
B0:
	0: CopyLoc[0](Arg0: &mut Referent<Ty0>)
	1: MutBorrowFieldGeneric[0](Referent.value: Option<Ty0>)
	2: Call option::extract<Ty0>(&mut Option<Ty0>): Ty0
	3: StLoc[2](loc1: Ty0)
	4: ImmBorrowLoc[2](loc1: Ty0)
	5: Call object::id<Ty0>(&Ty0): ID
	6: StLoc[1](loc0: ID)
	7: MoveLoc[2](loc1: Ty0)
	8: MoveLoc[0](Arg0: &mut Referent<Ty0>)
	9: ImmBorrowFieldGeneric[1](Referent.id: address)
	10: ReadRef
	11: MoveLoc[1](loc0: ID)
	12: Pack[1](Borrow)
	13: Ret
}

public put_back<Ty0: store + key>(Arg0: &mut Referent<Ty0>, Arg1: Ty0, Arg2: Borrow) {
L3:	loc0: ID
L4:	loc1: address
B0:
	0: MoveLoc[2](Arg2: Borrow)
	1: Unpack[1](Borrow)
	2: StLoc[3](loc0: ID)
	3: StLoc[4](loc1: address)
	4: ImmBorrowLoc[1](Arg1: Ty0)
	5: Call object::id<Ty0>(&Ty0): ID
	6: MoveLoc[3](loc0: ID)
	7: Eq
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[0](Arg0: &mut Referent<Ty0>)
	11: Pop
	12: LdConst[1](u64: 1)
	13: Abort
B3:
	14: CopyLoc[0](Arg0: &mut Referent<Ty0>)
	15: ImmBorrowFieldGeneric[1](Referent.id: address)
	16: ReadRef
	17: MoveLoc[4](loc1: address)
	18: Eq
	19: BrFalse(21)
B4:
	20: Branch(25)
B5:
	21: MoveLoc[0](Arg0: &mut Referent<Ty0>)
	22: Pop
	23: LdConst[0](u64: 0)
	24: Abort
B6:
	25: MoveLoc[0](Arg0: &mut Referent<Ty0>)
	26: MutBorrowFieldGeneric[0](Referent.value: Option<Ty0>)
	27: MoveLoc[1](Arg1: Ty0)
	28: Call option::fill<Ty0>(&mut Option<Ty0>, Ty0)
	29: Ret
}

public destroy<Ty0: store + key>(Arg0: Referent<Ty0>): Ty0 {
L1:	loc0: Option<Ty0>
B0:
	0: MoveLoc[0](Arg0: Referent<Ty0>)
	1: UnpackGeneric[0](Referent<Ty0>)
	2: StLoc[1](loc0: Option<Ty0>)
	3: Pop
	4: MoveLoc[1](loc0: Option<Ty0>)
	5: Call option::destroy_some<Ty0>(Option<Ty0>): Ty0
	6: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
]
}

// Move bytecode v6
module 2.clock {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Clock has key {
	id: UID,
	timestamp_ms: u64
}

public timestamp_ms(Arg0: &Clock): u64 {
B0:
	0: MoveLoc[0](Arg0: &Clock)
	1: ImmBorrowField[0](Clock.timestamp_ms: u64)
	2: ReadRef
	3: Ret
}

create(Arg0: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[1](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: Call object::clock(): UID
	9: LdU64(0)
	10: Pack[0](Clock)
	11: Call transfer::share_object<Clock>(Clock)
	12: Ret
}

consensus_commit_prologue(Arg0: &mut Clock, Arg1: u64, Arg2: &TxContext) {
B0:
	0: MoveLoc[2](Arg2: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[1](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &mut Clock)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: MoveLoc[1](Arg1: u64)
	11: MoveLoc[0](Arg0: &mut Clock)
	12: MutBorrowField[0](Clock.timestamp_ms: u64)
	13: WriteRef
	14: Ret
}

Constants [
	0 => u64: 0
	1 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 2.coin {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::deny_list;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::types;
use 0000000000000000000000000000000000000000000000000000000000000002::url;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

struct Coin<phantom Ty0> has store, key {
	id: UID,
	balance: Balance<Ty0>
}

struct CoinMetadata<phantom Ty0> has store, key {
	id: UID,
	decimals: u8,
	name: String,
	symbol: String,
	description: String,
	icon_url: Option<Url>
}

struct RegulatedCoinMetadata<phantom Ty0> has key {
	id: UID,
	coin_metadata_object: ID,
	deny_cap_object: ID
}

struct TreasuryCap<phantom Ty0> has store, key {
	id: UID,
	total_supply: Supply<Ty0>
}

struct DenyCapV2<phantom Ty0> has store, key {
	id: UID,
	allow_global_pause: bool
}

struct CurrencyCreated<phantom Ty0> has copy, drop {
	decimals: u8
}

struct DenyCap<phantom Ty0> has store, key {
	id: UID
}

public total_supply<Ty0>(Arg0: &TreasuryCap<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &TreasuryCap<Ty0>)
	1: ImmBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	2: Call balance::supply_value<Ty0>(&Supply<Ty0>): u64
	3: Ret
}

public treasury_into_supply<Ty0>(Arg0: TreasuryCap<Ty0>): Supply<Ty0> {
L1:	loc0: Supply<Ty0>
B0:
	0: MoveLoc[0](Arg0: TreasuryCap<Ty0>)
	1: UnpackGeneric[0](TreasuryCap<Ty0>)
	2: StLoc[1](loc0: Supply<Ty0>)
	3: Call object::delete(UID)
	4: MoveLoc[1](loc0: Supply<Ty0>)
	5: Ret
}

public supply_immut<Ty0>(Arg0: &TreasuryCap<Ty0>): &Supply<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &TreasuryCap<Ty0>)
	1: ImmBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	2: Ret
}

public supply_mut<Ty0>(Arg0: &mut TreasuryCap<Ty0>): &mut Supply<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	1: MutBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	2: Ret
}

public value<Ty0>(Arg0: &Coin<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Coin<Ty0>)
	1: ImmBorrowFieldGeneric[1](Coin.balance: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: Ret
}

public balance<Ty0>(Arg0: &Coin<Ty0>): &Balance<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &Coin<Ty0>)
	1: ImmBorrowFieldGeneric[1](Coin.balance: Balance<Ty0>)
	2: Ret
}

public balance_mut<Ty0>(Arg0: &mut Coin<Ty0>): &mut Balance<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	1: MutBorrowFieldGeneric[1](Coin.balance: Balance<Ty0>)
	2: Ret
}

public from_balance<Ty0>(Arg0: Balance<Ty0>, Arg1: &mut TxContext): Coin<Ty0> {
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: MoveLoc[0](Arg0: Balance<Ty0>)
	3: PackGeneric[1](Coin<Ty0>)
	4: Ret
}

public into_balance<Ty0>(Arg0: Coin<Ty0>): Balance<Ty0> {
L1:	loc0: Balance<Ty0>
B0:
	0: MoveLoc[0](Arg0: Coin<Ty0>)
	1: UnpackGeneric[1](Coin<Ty0>)
	2: StLoc[1](loc0: Balance<Ty0>)
	3: Call object::delete(UID)
	4: MoveLoc[1](loc0: Balance<Ty0>)
	5: Ret
}

public take<Ty0>(Arg0: &mut Balance<Ty0>, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
B0:
	0: MoveLoc[2](Arg2: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: MoveLoc[0](Arg0: &mut Balance<Ty0>)
	3: MoveLoc[1](Arg1: u64)
	4: Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	5: PackGeneric[1](Coin<Ty0>)
	6: Ret
}

public put<Ty0>(Arg0: &mut Balance<Ty0>, Arg1: Coin<Ty0>) {
B0:
	0: MoveLoc[0](Arg0: &mut Balance<Ty0>)
	1: MoveLoc[1](Arg1: Coin<Ty0>)
	2: Call into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
	3: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	4: Pop
	5: Ret
}

entry public join<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: Coin<Ty0>) {
L2:	loc0: Balance<Ty0>
B0:
	0: MoveLoc[1](Arg1: Coin<Ty0>)
	1: UnpackGeneric[1](Coin<Ty0>)
	2: StLoc[2](loc0: Balance<Ty0>)
	3: Call object::delete(UID)
	4: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	5: MutBorrowFieldGeneric[1](Coin.balance: Balance<Ty0>)
	6: MoveLoc[2](loc0: Balance<Ty0>)
	7: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	8: Pop
	9: Ret
}

public split<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	1: MutBorrowFieldGeneric[1](Coin.balance: Balance<Ty0>)
	2: MoveLoc[1](Arg1: u64)
	3: MoveLoc[2](Arg2: &mut TxContext)
	4: Call take<Ty0>(&mut Balance<Ty0>, u64, &mut TxContext): Coin<Ty0>
	5: Ret
}

public divide_into_n<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: u64, Arg2: &mut TxContext): vector<Coin<Ty0>> {
L3:	loc0: u64
L4:	loc1: Coin<Ty0>
L5:	loc2: &mut vector<Coin<Ty0>>
L6:	loc3: u64
L7:	loc4: u64
L8:	loc5: u64
L9:	loc6: u64
L10:	loc7: vector<Coin<Ty0>>
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdU64(0)
	2: Gt
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	6: Pop
	7: MoveLoc[2](Arg2: &mut TxContext)
	8: Pop
	9: LdConst[1](u64: 1)
	10: Abort
B3:
	11: CopyLoc[1](Arg1: u64)
	12: CopyLoc[0](Arg0: &mut Coin<Ty0>)
	13: FreezeRef
	14: Call value<Ty0>(&Coin<Ty0>): u64
	15: Le
	16: BrFalse(18)
B4:
	17: Branch(24)
B5:
	18: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	19: Pop
	20: MoveLoc[2](Arg2: &mut TxContext)
	21: Pop
	22: LdConst[2](u64: 2)
	23: Abort
B6:
	24: CopyLoc[0](Arg0: &mut Coin<Ty0>)
	25: FreezeRef
	26: Call value<Ty0>(&Coin<Ty0>): u64
	27: CopyLoc[1](Arg1: u64)
	28: Div
	29: StLoc[8](loc5: u64)
	30: VecPack(12, 0)
	31: StLoc[10](loc7: vector<Coin<Ty0>>)
	32: MoveLoc[1](Arg1: u64)
	33: LdU64(1)
	34: Sub
	35: StLoc[3](loc0: u64)
	36: LdU64(0)
	37: StLoc[7](loc4: u64)
	38: MoveLoc[3](loc0: u64)
	39: StLoc[9](loc6: u64)
B7:
	40: CopyLoc[7](loc4: u64)
	41: CopyLoc[9](loc6: u64)
	42: Lt
	43: BrFalse(63)
B8:
	44: CopyLoc[7](loc4: u64)
	45: StLoc[6](loc3: u64)
	46: MutBorrowLoc[10](loc7: vector<Coin<Ty0>>)
	47: StLoc[5](loc2: &mut vector<Coin<Ty0>>)
	48: MoveLoc[6](loc3: u64)
	49: Pop
	50: CopyLoc[0](Arg0: &mut Coin<Ty0>)
	51: CopyLoc[8](loc5: u64)
	52: CopyLoc[2](Arg2: &mut TxContext)
	53: Call split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
	54: StLoc[4](loc1: Coin<Ty0>)
	55: MoveLoc[5](loc2: &mut vector<Coin<Ty0>>)
	56: MoveLoc[4](loc1: Coin<Ty0>)
	57: VecPushBack(12)
	58: MoveLoc[7](loc4: u64)
	59: LdU64(1)
	60: Add
	61: StLoc[7](loc4: u64)
	62: Branch(40)
B9:
	63: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	64: Pop
	65: MoveLoc[2](Arg2: &mut TxContext)
	66: Pop
	67: MoveLoc[10](loc7: vector<Coin<Ty0>>)
	68: Ret
}

public zero<Ty0>(Arg0: &mut TxContext): Coin<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Call balance::zero<Ty0>(): Balance<Ty0>
	3: PackGeneric[1](Coin<Ty0>)
	4: Ret
}

public destroy_zero<Ty0>(Arg0: Coin<Ty0>) {
L1:	loc0: Balance<Ty0>
B0:
	0: MoveLoc[0](Arg0: Coin<Ty0>)
	1: UnpackGeneric[1](Coin<Ty0>)
	2: StLoc[1](loc0: Balance<Ty0>)
	3: Call object::delete(UID)
	4: MoveLoc[1](loc0: Balance<Ty0>)
	5: Call balance::destroy_zero<Ty0>(Balance<Ty0>)
	6: Ret
}

public create_currency<Ty0: drop>(Arg0: Ty0, Arg1: u8, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: Option<Url>, Arg6: &mut TxContext): TreasuryCap<Ty0> * CoinMetadata<Ty0> {
B0:
	0: ImmBorrowLoc[0](Arg0: Ty0)
	1: Call types::is_one_time_witness<Ty0>(&Ty0): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[6](Arg6: &mut TxContext)
	5: Pop
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: CopyLoc[6](Arg6: &mut TxContext)
	9: Call object::new(&mut TxContext): UID
	10: MoveLoc[0](Arg0: Ty0)
	11: Call balance::create_supply<Ty0>(Ty0): Supply<Ty0>
	12: PackGeneric[0](TreasuryCap<Ty0>)
	13: MoveLoc[6](Arg6: &mut TxContext)
	14: Call object::new(&mut TxContext): UID
	15: MoveLoc[1](Arg1: u8)
	16: MoveLoc[3](Arg3: vector<u8>)
	17: Call string::utf8(vector<u8>): String
	18: MoveLoc[2](Arg2: vector<u8>)
	19: Call ascii::string(vector<u8>): String
	20: MoveLoc[4](Arg4: vector<u8>)
	21: Call string::utf8(vector<u8>): String
	22: MoveLoc[5](Arg5: Option<Url>)
	23: PackGeneric[2](CoinMetadata<Ty0>)
	24: Ret
}

public create_regulated_currency_v2<Ty0: drop>(Arg0: Ty0, Arg1: u8, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: Option<Url>, Arg6: bool, Arg7: &mut TxContext): TreasuryCap<Ty0> * DenyCapV2<Ty0> * CoinMetadata<Ty0> {
L8:	loc0: DenyCapV2<Ty0>
L9:	loc1: CoinMetadata<Ty0>
L10:	loc2: TreasuryCap<Ty0>
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: MoveLoc[1](Arg1: u8)
	2: MoveLoc[2](Arg2: vector<u8>)
	3: MoveLoc[3](Arg3: vector<u8>)
	4: MoveLoc[4](Arg4: vector<u8>)
	5: MoveLoc[5](Arg5: Option<Url>)
	6: CopyLoc[7](Arg7: &mut TxContext)
	7: Call create_currency<Ty0>(Ty0, u8, vector<u8>, vector<u8>, vector<u8>, Option<Url>, &mut TxContext): TreasuryCap<Ty0> * CoinMetadata<Ty0>
	8: StLoc[9](loc1: CoinMetadata<Ty0>)
	9: StLoc[10](loc2: TreasuryCap<Ty0>)
	10: CopyLoc[7](Arg7: &mut TxContext)
	11: Call object::new(&mut TxContext): UID
	12: MoveLoc[6](Arg6: bool)
	13: PackGeneric[3](DenyCapV2<Ty0>)
	14: StLoc[8](loc0: DenyCapV2<Ty0>)
	15: MoveLoc[7](Arg7: &mut TxContext)
	16: Call object::new(&mut TxContext): UID
	17: ImmBorrowLoc[9](loc1: CoinMetadata<Ty0>)
	18: Call object::id<CoinMetadata<Ty0>>(&CoinMetadata<Ty0>): ID
	19: ImmBorrowLoc[8](loc0: DenyCapV2<Ty0>)
	20: Call object::id<DenyCapV2<Ty0>>(&DenyCapV2<Ty0>): ID
	21: PackGeneric[4](RegulatedCoinMetadata<Ty0>)
	22: Call transfer::freeze_object<RegulatedCoinMetadata<Ty0>>(RegulatedCoinMetadata<Ty0>)
	23: MoveLoc[10](loc2: TreasuryCap<Ty0>)
	24: MoveLoc[8](loc0: DenyCapV2<Ty0>)
	25: MoveLoc[9](loc1: CoinMetadata<Ty0>)
	26: Ret
}

public migrate_regulated_currency_to_v2<Ty0>(Arg0: &mut DenyList, Arg1: DenyCap<Ty0>, Arg2: bool, Arg3: &mut TxContext): DenyCapV2<Ty0> {
L4:	loc0: vector<u8>
B0:
	0: MoveLoc[1](Arg1: DenyCap<Ty0>)
	1: UnpackGeneric[5](DenyCap<Ty0>)
	2: Call object::delete(UID)
	3: Call type_name::get_with_original_ids<Ty0>(): TypeName
	4: Call type_name::into_string(TypeName): String
	5: Call ascii::into_bytes(String): vector<u8>
	6: StLoc[4](loc0: vector<u8>)
	7: MoveLoc[0](Arg0: &mut DenyList)
	8: LdConst[0](u64: 0)
	9: MoveLoc[4](loc0: vector<u8>)
	10: CopyLoc[3](Arg3: &mut TxContext)
	11: Call deny_list::migrate_v1_to_v2(&mut DenyList, u64, vector<u8>, &mut TxContext)
	12: MoveLoc[3](Arg3: &mut TxContext)
	13: Call object::new(&mut TxContext): UID
	14: MoveLoc[2](Arg2: bool)
	15: PackGeneric[3](DenyCapV2<Ty0>)
	16: Ret
}

public mint<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
B0:
	0: MoveLoc[2](Arg2: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	3: MutBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	4: MoveLoc[1](Arg1: u64)
	5: Call balance::increase_supply<Ty0>(&mut Supply<Ty0>, u64): Balance<Ty0>
	6: PackGeneric[1](Coin<Ty0>)
	7: Ret
}

public mint_balance<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: u64): Balance<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	1: MutBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	2: MoveLoc[1](Arg1: u64)
	3: Call balance::increase_supply<Ty0>(&mut Supply<Ty0>, u64): Balance<Ty0>
	4: Ret
}

entry public burn<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: Coin<Ty0>): u64 {
L2:	loc0: Balance<Ty0>
B0:
	0: MoveLoc[1](Arg1: Coin<Ty0>)
	1: UnpackGeneric[1](Coin<Ty0>)
	2: StLoc[2](loc0: Balance<Ty0>)
	3: Call object::delete(UID)
	4: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	5: MutBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	6: MoveLoc[2](loc0: Balance<Ty0>)
	7: Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64
	8: Ret
}

public deny_list_v2_add<Ty0>(Arg0: &mut DenyList, Arg1: &mut DenyCapV2<Ty0>, Arg2: address, Arg3: &mut TxContext) {
L4:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[4](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &mut DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[4](loc0: vector<u8>)
	7: MoveLoc[2](Arg2: address)
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Call deny_list::v2_add(&mut DenyList, u64, vector<u8>, address, &mut TxContext)
	10: Ret
}

public deny_list_v2_remove<Ty0>(Arg0: &mut DenyList, Arg1: &mut DenyCapV2<Ty0>, Arg2: address, Arg3: &mut TxContext) {
L4:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[4](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &mut DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[4](loc0: vector<u8>)
	7: MoveLoc[2](Arg2: address)
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Call deny_list::v2_remove(&mut DenyList, u64, vector<u8>, address, &mut TxContext)
	10: Ret
}

public deny_list_v2_contains_current_epoch<Ty0>(Arg0: &DenyList, Arg1: address, Arg2: &TxContext): bool {
L3:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[3](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[3](loc0: vector<u8>)
	7: MoveLoc[1](Arg1: address)
	8: MoveLoc[2](Arg2: &TxContext)
	9: Call deny_list::v2_contains_current_epoch(&DenyList, u64, vector<u8>, address, &TxContext): bool
	10: Ret
}

public deny_list_v2_contains_next_epoch<Ty0>(Arg0: &DenyList, Arg1: address): bool {
L2:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[2](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[2](loc0: vector<u8>)
	7: MoveLoc[1](Arg1: address)
	8: Call deny_list::v2_contains_next_epoch(&DenyList, u64, vector<u8>, address): bool
	9: Ret
}

public deny_list_v2_enable_global_pause<Ty0>(Arg0: &mut DenyList, Arg1: &mut DenyCapV2<Ty0>, Arg2: &mut TxContext) {
L3:	loc0: vector<u8>
B0:
	0: MoveLoc[1](Arg1: &mut DenyCapV2<Ty0>)
	1: ImmBorrowFieldGeneric[2](DenyCapV2.allow_global_pause: bool)
	2: ReadRef
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut DenyList)
	6: Pop
	7: MoveLoc[2](Arg2: &mut TxContext)
	8: Pop
	9: LdConst[3](u64: 3)
	10: Abort
B3:
	11: Call type_name::get_with_original_ids<Ty0>(): TypeName
	12: Call type_name::into_string(TypeName): String
	13: Call ascii::into_bytes(String): vector<u8>
	14: StLoc[3](loc0: vector<u8>)
	15: MoveLoc[0](Arg0: &mut DenyList)
	16: LdConst[0](u64: 0)
	17: MoveLoc[3](loc0: vector<u8>)
	18: MoveLoc[2](Arg2: &mut TxContext)
	19: Call deny_list::v2_enable_global_pause(&mut DenyList, u64, vector<u8>, &mut TxContext)
	20: Ret
}

public deny_list_v2_disable_global_pause<Ty0>(Arg0: &mut DenyList, Arg1: &mut DenyCapV2<Ty0>, Arg2: &mut TxContext) {
L3:	loc0: vector<u8>
B0:
	0: MoveLoc[1](Arg1: &mut DenyCapV2<Ty0>)
	1: ImmBorrowFieldGeneric[2](DenyCapV2.allow_global_pause: bool)
	2: ReadRef
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut DenyList)
	6: Pop
	7: MoveLoc[2](Arg2: &mut TxContext)
	8: Pop
	9: LdConst[3](u64: 3)
	10: Abort
B3:
	11: Call type_name::get_with_original_ids<Ty0>(): TypeName
	12: Call type_name::into_string(TypeName): String
	13: Call ascii::into_bytes(String): vector<u8>
	14: StLoc[3](loc0: vector<u8>)
	15: MoveLoc[0](Arg0: &mut DenyList)
	16: LdConst[0](u64: 0)
	17: MoveLoc[3](loc0: vector<u8>)
	18: MoveLoc[2](Arg2: &mut TxContext)
	19: Call deny_list::v2_disable_global_pause(&mut DenyList, u64, vector<u8>, &mut TxContext)
	20: Ret
}

public deny_list_v2_is_global_pause_enabled_current_epoch<Ty0>(Arg0: &DenyList, Arg1: &TxContext): bool {
L2:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[2](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[2](loc0: vector<u8>)
	7: MoveLoc[1](Arg1: &TxContext)
	8: Call deny_list::v2_is_global_pause_enabled_current_epoch(&DenyList, u64, vector<u8>, &TxContext): bool
	9: Ret
}

public deny_list_v2_is_global_pause_enabled_next_epoch<Ty0>(Arg0: &DenyList): bool {
L1:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[1](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[1](loc0: vector<u8>)
	7: Call deny_list::v2_is_global_pause_enabled_next_epoch(&DenyList, u64, vector<u8>): bool
	8: Ret
}

entry public mint_and_transfer<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: u64, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	1: MoveLoc[1](Arg1: u64)
	2: MoveLoc[3](Arg3: &mut TxContext)
	3: Call mint<Ty0>(&mut TreasuryCap<Ty0>, u64, &mut TxContext): Coin<Ty0>
	4: MoveLoc[2](Arg2: address)
	5: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
	6: Ret
}

entry public update_name<Ty0>(Arg0: &TreasuryCap<Ty0>, Arg1: &mut CoinMetadata<Ty0>, Arg2: String) {
B0:
	0: MoveLoc[2](Arg2: String)
	1: MoveLoc[1](Arg1: &mut CoinMetadata<Ty0>)
	2: MutBorrowFieldGeneric[3](CoinMetadata.name: String)
	3: WriteRef
	4: Ret
}

entry public update_symbol<Ty0>(Arg0: &TreasuryCap<Ty0>, Arg1: &mut CoinMetadata<Ty0>, Arg2: String) {
B0:
	0: MoveLoc[2](Arg2: String)
	1: MoveLoc[1](Arg1: &mut CoinMetadata<Ty0>)
	2: MutBorrowFieldGeneric[4](CoinMetadata.symbol: String)
	3: WriteRef
	4: Ret
}

entry public update_description<Ty0>(Arg0: &TreasuryCap<Ty0>, Arg1: &mut CoinMetadata<Ty0>, Arg2: String) {
B0:
	0: MoveLoc[2](Arg2: String)
	1: MoveLoc[1](Arg1: &mut CoinMetadata<Ty0>)
	2: MutBorrowFieldGeneric[5](CoinMetadata.description: String)
	3: WriteRef
	4: Ret
}

entry public update_icon_url<Ty0>(Arg0: &TreasuryCap<Ty0>, Arg1: &mut CoinMetadata<Ty0>, Arg2: String) {
B0:
	0: MoveLoc[2](Arg2: String)
	1: Call url::new_unsafe(String): Url
	2: Call option::some<Url>(Url): Option<Url>
	3: MoveLoc[1](Arg1: &mut CoinMetadata<Ty0>)
	4: MutBorrowFieldGeneric[6](CoinMetadata.icon_url: Option<Url>)
	5: WriteRef
	6: Ret
}

public get_decimals<Ty0>(Arg0: &CoinMetadata<Ty0>): u8 {
B0:
	0: MoveLoc[0](Arg0: &CoinMetadata<Ty0>)
	1: ImmBorrowFieldGeneric[7](CoinMetadata.decimals: u8)
	2: ReadRef
	3: Ret
}

public get_name<Ty0>(Arg0: &CoinMetadata<Ty0>): String {
B0:
	0: MoveLoc[0](Arg0: &CoinMetadata<Ty0>)
	1: ImmBorrowFieldGeneric[3](CoinMetadata.name: String)
	2: ReadRef
	3: Ret
}

public get_symbol<Ty0>(Arg0: &CoinMetadata<Ty0>): String {
B0:
	0: MoveLoc[0](Arg0: &CoinMetadata<Ty0>)
	1: ImmBorrowFieldGeneric[4](CoinMetadata.symbol: String)
	2: ReadRef
	3: Ret
}

public get_description<Ty0>(Arg0: &CoinMetadata<Ty0>): String {
B0:
	0: MoveLoc[0](Arg0: &CoinMetadata<Ty0>)
	1: ImmBorrowFieldGeneric[5](CoinMetadata.description: String)
	2: ReadRef
	3: Ret
}

public get_icon_url<Ty0>(Arg0: &CoinMetadata<Ty0>): Option<Url> {
B0:
	0: MoveLoc[0](Arg0: &CoinMetadata<Ty0>)
	1: ImmBorrowFieldGeneric[6](CoinMetadata.icon_url: Option<Url>)
	2: ReadRef
	3: Ret
}

public supply<Ty0>(Arg0: &mut TreasuryCap<Ty0>): &Supply<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	1: ImmBorrowFieldGeneric[0](TreasuryCap.total_supply: Supply<Ty0>)
	2: Ret
}

public create_regulated_currency<Ty0: drop>(Arg0: Ty0, Arg1: u8, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: vector<u8>, Arg5: Option<Url>, Arg6: &mut TxContext): TreasuryCap<Ty0> * DenyCap<Ty0> * CoinMetadata<Ty0> {
L7:	loc0: DenyCap<Ty0>
L8:	loc1: CoinMetadata<Ty0>
L9:	loc2: TreasuryCap<Ty0>
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: MoveLoc[1](Arg1: u8)
	2: MoveLoc[2](Arg2: vector<u8>)
	3: MoveLoc[3](Arg3: vector<u8>)
	4: MoveLoc[4](Arg4: vector<u8>)
	5: MoveLoc[5](Arg5: Option<Url>)
	6: CopyLoc[6](Arg6: &mut TxContext)
	7: Call create_currency<Ty0>(Ty0, u8, vector<u8>, vector<u8>, vector<u8>, Option<Url>, &mut TxContext): TreasuryCap<Ty0> * CoinMetadata<Ty0>
	8: StLoc[8](loc1: CoinMetadata<Ty0>)
	9: StLoc[9](loc2: TreasuryCap<Ty0>)
	10: CopyLoc[6](Arg6: &mut TxContext)
	11: Call object::new(&mut TxContext): UID
	12: PackGeneric[5](DenyCap<Ty0>)
	13: StLoc[7](loc0: DenyCap<Ty0>)
	14: MoveLoc[6](Arg6: &mut TxContext)
	15: Call object::new(&mut TxContext): UID
	16: ImmBorrowLoc[8](loc1: CoinMetadata<Ty0>)
	17: Call object::id<CoinMetadata<Ty0>>(&CoinMetadata<Ty0>): ID
	18: ImmBorrowLoc[7](loc0: DenyCap<Ty0>)
	19: Call object::id<DenyCap<Ty0>>(&DenyCap<Ty0>): ID
	20: PackGeneric[4](RegulatedCoinMetadata<Ty0>)
	21: Call transfer::freeze_object<RegulatedCoinMetadata<Ty0>>(RegulatedCoinMetadata<Ty0>)
	22: MoveLoc[9](loc2: TreasuryCap<Ty0>)
	23: MoveLoc[7](loc0: DenyCap<Ty0>)
	24: MoveLoc[8](loc1: CoinMetadata<Ty0>)
	25: Ret
}

public deny_list_add<Ty0>(Arg0: &mut DenyList, Arg1: &mut DenyCap<Ty0>, Arg2: address, Arg3: &mut TxContext) {
L4:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[4](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &mut DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[4](loc0: vector<u8>)
	7: MoveLoc[2](Arg2: address)
	8: Call deny_list::v1_add(&mut DenyList, u64, vector<u8>, address)
	9: Ret
}

public deny_list_remove<Ty0>(Arg0: &mut DenyList, Arg1: &mut DenyCap<Ty0>, Arg2: address, Arg3: &mut TxContext) {
L4:	loc0: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: Call type_name::into_string(TypeName): String
	2: Call ascii::into_bytes(String): vector<u8>
	3: StLoc[4](loc0: vector<u8>)
	4: MoveLoc[0](Arg0: &mut DenyList)
	5: LdConst[0](u64: 0)
	6: MoveLoc[4](loc0: vector<u8>)
	7: MoveLoc[2](Arg2: address)
	8: Call deny_list::v1_remove(&mut DenyList, u64, vector<u8>, address)
	9: Ret
}

public deny_list_contains<Ty0>(Arg0: &DenyList, Arg1: address): bool {
L2:	loc0: TypeName
L3:	loc1: vector<u8>
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: StLoc[2](loc0: TypeName)
	2: ImmBorrowLoc[2](loc0: TypeName)
	3: Call type_name::is_primitive(&TypeName): bool
	4: BrFalse(9)
B1:
	5: MoveLoc[0](Arg0: &DenyList)
	6: Pop
	7: LdFalse
	8: Ret
B2:
	9: MoveLoc[2](loc0: TypeName)
	10: Call type_name::into_string(TypeName): String
	11: Call ascii::into_bytes(String): vector<u8>
	12: StLoc[3](loc1: vector<u8>)
	13: MoveLoc[0](Arg0: &DenyList)
	14: LdConst[0](u64: 0)
	15: MoveLoc[3](loc1: vector<u8>)
	16: MoveLoc[1](Arg1: address)
	17: Call deny_list::v1_contains(&DenyList, u64, vector<u8>, address): bool
	18: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
]
}

// Move bytecode v6
module 2.config {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct Config<phantom Ty0> has key {
	id: UID
}

struct Setting<Ty0: copy + drop + store> has drop, store {
	data: Option<SettingData<Ty0>>
}

struct SettingData<Ty0: copy + drop + store> has drop, store {
	newer_value_epoch: u64,
	newer_value: Option<Ty0>,
	older_value_opt: Option<Ty0>
}

public(friend) new<Ty0>(Arg0: &mut Ty0, Arg1: &mut TxContext): Config<Ty0> {
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: PackGeneric[0](Config<Ty0>)
	3: Ret
}

public(friend) share<Ty0>(Arg0: Config<Ty0>) {
B0:
	0: MoveLoc[0](Arg0: Config<Ty0>)
	1: Call transfer::share_object<Config<Ty0>>(Config<Ty0>)
	2: Ret
}

public(friend) transfer<Ty0>(Arg0: Config<Ty0>, Arg1: address) {
B0:
	0: MoveLoc[0](Arg0: Config<Ty0>)
	1: MoveLoc[1](Arg1: address)
	2: Call transfer::transfer<Config<Ty0>>(Config<Ty0>, address)
	3: Ret
}

public(friend) add_for_next_epoch<Ty0, Ty1: copy + drop + store, Ty2: copy + drop + store>(Arg0: &mut Config<Ty0>, Arg1: &mut Ty0, Arg2: Ty1, Arg3: Ty2, Arg4: &mut TxContext): Option<Ty2> {
L5:	loc0: Option<Ty2>
L6:	loc1: Option<Ty2>
L7:	loc2: Option<Ty2>
L8:	loc3: u64
L9:	loc4: Option<Ty2>
L10:	loc5: u64
L11:	loc6: Option<Ty2>
L12:	loc7: Option<Ty2>
L13:	loc8: Option<Ty2>
L14:	loc9: Setting<Ty2>
L15:	loc10: &mut Setting<Ty2>
B0:
	0: MoveLoc[4](Arg4: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: StLoc[8](loc3: u64)
	4: CopyLoc[0](Arg0: &mut Config<Ty0>)
	5: ImmBorrowFieldGeneric[0](Config.id: UID)
	6: CopyLoc[2](Arg2: Ty1)
	7: Call dynamic_field::exists_<Ty1>(&UID, Ty1): bool
	8: Not
	9: BrFalse(26)
B1:
	10: MoveLoc[8](loc3: u64)
	11: MoveLoc[3](Arg3: Ty2)
	12: Call option::some<Ty2>(Ty2): Option<Ty2>
	13: Call option::none<Ty2>(): Option<Ty2>
	14: PackGeneric[1](SettingData<Ty2>)
	15: Call option::some<SettingData<Ty2>>(SettingData<Ty2>): Option<SettingData<Ty2>>
	16: PackGeneric[2](Setting<Ty2>)
	17: StLoc[14](loc9: Setting<Ty2>)
	18: MoveLoc[0](Arg0: &mut Config<Ty0>)
	19: MutBorrowFieldGeneric[0](Config.id: UID)
	20: MoveLoc[2](Arg2: Ty1)
	21: MoveLoc[14](loc9: Setting<Ty2>)
	22: Call dynamic_field::add<Ty1, Setting<Ty2>>(&mut UID, Ty1, Setting<Ty2>)
	23: Call option::none<Ty2>(): Option<Ty2>
	24: StLoc[7](loc2: Option<Ty2>)
	25: Branch(82)
B2:
	26: MoveLoc[0](Arg0: &mut Config<Ty0>)
	27: MutBorrowFieldGeneric[0](Config.id: UID)
	28: MoveLoc[2](Arg2: Ty1)
	29: Call dynamic_field::borrow_mut<Ty1, Setting<Ty2>>(&mut UID, Ty1): &mut Setting<Ty2>
	30: StLoc[15](loc10: &mut Setting<Ty2>)
	31: CopyLoc[15](loc10: &mut Setting<Ty2>)
	32: MutBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	33: Call option::extract<SettingData<Ty2>>(&mut Option<SettingData<Ty2>>): SettingData<Ty2>
	34: UnpackGeneric[1](SettingData<Ty2>)
	35: StLoc[11](loc6: Option<Ty2>)
	36: StLoc[9](loc4: Option<Ty2>)
	37: StLoc[10](loc5: u64)
	38: CopyLoc[8](loc3: u64)
	39: CopyLoc[10](loc5: u64)
	40: Gt
	41: BrFalse(47)
B3:
	42: MoveLoc[9](loc4: Option<Ty2>)
	43: MoveLoc[11](loc6: Option<Ty2>)
	44: StLoc[6](loc1: Option<Ty2>)
	45: StLoc[5](loc0: Option<Ty2>)
	46: Branch(68)
B4:
	47: CopyLoc[8](loc3: u64)
	48: MoveLoc[10](loc5: u64)
	49: Eq
	50: BrFalse(52)
B5:
	51: Branch(56)
B6:
	52: MoveLoc[15](loc10: &mut Setting<Ty2>)
	53: Pop
	54: LdU64(13906834548005535743)
	55: Abort
B7:
	56: ImmBorrowLoc[9](loc4: Option<Ty2>)
	57: Call option::is_none<Ty2>(&Option<Ty2>): bool
	58: BrFalse(60)
B8:
	59: Branch(64)
B9:
	60: MoveLoc[15](loc10: &mut Setting<Ty2>)
	61: Pop
	62: LdConst[0](u64: 0)
	63: Abort
B10:
	64: MoveLoc[11](loc6: Option<Ty2>)
	65: Call option::none<Ty2>(): Option<Ty2>
	66: StLoc[6](loc1: Option<Ty2>)
	67: StLoc[5](loc0: Option<Ty2>)
B11:
	68: MoveLoc[5](loc0: Option<Ty2>)
	69: MoveLoc[6](loc1: Option<Ty2>)
	70: StLoc[13](loc8: Option<Ty2>)
	71: StLoc[12](loc7: Option<Ty2>)
	72: MoveLoc[15](loc10: &mut Setting<Ty2>)
	73: MutBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	74: MoveLoc[8](loc3: u64)
	75: MoveLoc[3](Arg3: Ty2)
	76: Call option::some<Ty2>(Ty2): Option<Ty2>
	77: MoveLoc[12](loc7: Option<Ty2>)
	78: PackGeneric[1](SettingData<Ty2>)
	79: Call option::fill<SettingData<Ty2>>(&mut Option<SettingData<Ty2>>, SettingData<Ty2>)
	80: MoveLoc[13](loc8: Option<Ty2>)
	81: StLoc[7](loc2: Option<Ty2>)
B12:
	82: MoveLoc[7](loc2: Option<Ty2>)
	83: Ret
}

public(friend) remove_for_next_epoch<Ty0, Ty1: copy + drop + store, Ty2: copy + drop + store>(Arg0: &mut Config<Ty0>, Arg1: &mut Ty0, Arg2: Ty1, Arg3: &mut TxContext): Option<Ty2> {
L4:	loc0: Option<Ty2>
L5:	loc1: Option<Ty2>
L6:	loc2: u64
L7:	loc3: Option<Ty2>
L8:	loc4: u64
L9:	loc5: Option<Ty2>
L10:	loc6: Option<Ty2>
L11:	loc7: bool
L12:	loc8: Option<Ty2>
L13:	loc9: &mut Setting<Ty2>
B0:
	0: MoveLoc[3](Arg3: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: StLoc[6](loc2: u64)
	4: CopyLoc[0](Arg0: &mut Config<Ty0>)
	5: ImmBorrowFieldGeneric[0](Config.id: UID)
	6: CopyLoc[2](Arg2: Ty1)
	7: Call dynamic_field::exists_<Ty1>(&UID, Ty1): bool
	8: Not
	9: BrFalse(14)
B1:
	10: MoveLoc[0](Arg0: &mut Config<Ty0>)
	11: Pop
	12: Call option::none<Ty2>(): Option<Ty2>
	13: Ret
B2:
	14: CopyLoc[0](Arg0: &mut Config<Ty0>)
	15: MutBorrowFieldGeneric[0](Config.id: UID)
	16: CopyLoc[2](Arg2: Ty1)
	17: Call dynamic_field::borrow_mut<Ty1, Setting<Ty2>>(&mut UID, Ty1): &mut Setting<Ty2>
	18: StLoc[13](loc9: &mut Setting<Ty2>)
	19: CopyLoc[13](loc9: &mut Setting<Ty2>)
	20: MutBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	21: Call option::extract<SettingData<Ty2>>(&mut Option<SettingData<Ty2>>): SettingData<Ty2>
	22: UnpackGeneric[1](SettingData<Ty2>)
	23: StLoc[9](loc5: Option<Ty2>)
	24: StLoc[7](loc3: Option<Ty2>)
	25: StLoc[8](loc4: u64)
	26: CopyLoc[6](loc2: u64)
	27: CopyLoc[8](loc4: u64)
	28: Gt
	29: BrFalse(35)
B3:
	30: MoveLoc[7](loc3: Option<Ty2>)
	31: Call option::none<Ty2>(): Option<Ty2>
	32: StLoc[5](loc1: Option<Ty2>)
	33: StLoc[4](loc0: Option<Ty2>)
	34: Branch(50)
B4:
	35: CopyLoc[6](loc2: u64)
	36: MoveLoc[8](loc4: u64)
	37: Eq
	38: BrFalse(40)
B5:
	39: Branch(46)
B6:
	40: MoveLoc[13](loc9: &mut Setting<Ty2>)
	41: Pop
	42: MoveLoc[0](Arg0: &mut Config<Ty0>)
	43: Pop
	44: LdU64(13906834719804227583)
	45: Abort
B7:
	46: MoveLoc[9](loc5: Option<Ty2>)
	47: MoveLoc[7](loc3: Option<Ty2>)
	48: StLoc[5](loc1: Option<Ty2>)
	49: StLoc[4](loc0: Option<Ty2>)
B8:
	50: MoveLoc[4](loc0: Option<Ty2>)
	51: MoveLoc[5](loc1: Option<Ty2>)
	52: StLoc[12](loc8: Option<Ty2>)
	53: StLoc[10](loc6: Option<Ty2>)
	54: ImmBorrowLoc[10](loc6: Option<Ty2>)
	55: Call option::is_none<Ty2>(&Option<Ty2>): bool
	56: StLoc[11](loc7: bool)
	57: MoveLoc[13](loc9: &mut Setting<Ty2>)
	58: MutBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	59: MoveLoc[6](loc2: u64)
	60: Call option::none<Ty2>(): Option<Ty2>
	61: MoveLoc[10](loc6: Option<Ty2>)
	62: PackGeneric[1](SettingData<Ty2>)
	63: Call option::fill<SettingData<Ty2>>(&mut Option<SettingData<Ty2>>, SettingData<Ty2>)
	64: MoveLoc[11](loc7: bool)
	65: BrFalse(72)
B9:
	66: MoveLoc[0](Arg0: &mut Config<Ty0>)
	67: MutBorrowFieldGeneric[0](Config.id: UID)
	68: MoveLoc[2](Arg2: Ty1)
	69: Call dynamic_field::remove<Ty1, Setting<Ty2>>(&mut UID, Ty1): Setting<Ty2>
	70: Pop
	71: Branch(74)
B10:
	72: MoveLoc[0](Arg0: &mut Config<Ty0>)
	73: Pop
B11:
	74: MoveLoc[12](loc8: Option<Ty2>)
	75: Ret
}

public(friend) exists_with_type<Ty0, Ty1: copy + drop + store, Ty2: copy + drop + store>(Arg0: &Config<Ty0>, Arg1: Ty1): bool {
B0:
	0: MoveLoc[0](Arg0: &Config<Ty0>)
	1: ImmBorrowFieldGeneric[0](Config.id: UID)
	2: MoveLoc[1](Arg1: Ty1)
	3: Call dynamic_field::exists_with_type<Ty1, Setting<Ty2>>(&UID, Ty1): bool
	4: Ret
}

public(friend) exists_with_type_for_next_epoch<Ty0, Ty1: copy + drop + store, Ty2: copy + drop + store>(Arg0: &Config<Ty0>, Arg1: Ty1, Arg2: &TxContext): bool {
L3:	loc0: bool
L4:	loc1: bool
L5:	loc2: u64
L6:	loc3: &Setting<Ty2>
B0:
	0: CopyLoc[0](Arg0: &Config<Ty0>)
	1: ImmBorrowFieldGeneric[0](Config.id: UID)
	2: CopyLoc[1](Arg1: Ty1)
	3: Call dynamic_field::exists_with_type<Ty1, Setting<Ty2>>(&UID, Ty1): bool
	4: BrFalse(35)
B1:
	5: MoveLoc[2](Arg2: &TxContext)
	6: Call tx_context::epoch(&TxContext): u64
	7: StLoc[5](loc2: u64)
	8: MoveLoc[0](Arg0: &Config<Ty0>)
	9: ImmBorrowFieldGeneric[0](Config.id: UID)
	10: MoveLoc[1](Arg1: Ty1)
	11: Call dynamic_field::borrow<Ty1, Setting<Ty2>>(&UID, Ty1): &Setting<Ty2>
	12: StLoc[6](loc3: &Setting<Ty2>)
	13: MoveLoc[5](loc2: u64)
	14: CopyLoc[6](loc3: &Setting<Ty2>)
	15: ImmBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	16: Call option::borrow<SettingData<Ty2>>(&Option<SettingData<Ty2>>): &SettingData<Ty2>
	17: ImmBorrowFieldGeneric[2](SettingData.newer_value_epoch: u64)
	18: ReadRef
	19: Eq
	20: BrFalse(28)
B2:
	21: MoveLoc[6](loc3: &Setting<Ty2>)
	22: ImmBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	23: Call option::borrow<SettingData<Ty2>>(&Option<SettingData<Ty2>>): &SettingData<Ty2>
	24: ImmBorrowFieldGeneric[3](SettingData.newer_value: Option<Ty2>)
	25: Call option::is_some<Ty2>(&Option<Ty2>): bool
	26: StLoc[4](loc1: bool)
	27: Branch(32)
B3:
	28: MoveLoc[6](loc3: &Setting<Ty2>)
	29: Pop
	30: LdFalse
	31: StLoc[4](loc1: bool)
B4:
	32: MoveLoc[4](loc1: bool)
	33: StLoc[3](loc0: bool)
	34: Branch(41)
B5:
	35: MoveLoc[2](Arg2: &TxContext)
	36: Pop
	37: MoveLoc[0](Arg0: &Config<Ty0>)
	38: Pop
	39: LdFalse
	40: StLoc[3](loc0: bool)
B6:
	41: MoveLoc[3](loc0: bool)
	42: Ret
}

public(friend) borrow_for_next_epoch_mut<Ty0, Ty1: copy + drop + store, Ty2: copy + drop + store>(Arg0: &mut Config<Ty0>, Arg1: &mut Ty0, Arg2: Ty1, Arg3: &mut TxContext): &mut Ty2 {
L4:	loc0: &mut SettingData<Ty2>
L5:	loc1: u64
B0:
	0: MoveLoc[3](Arg3: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::epoch(&TxContext): u64
	3: StLoc[5](loc1: u64)
	4: MoveLoc[0](Arg0: &mut Config<Ty0>)
	5: MutBorrowFieldGeneric[0](Config.id: UID)
	6: MoveLoc[2](Arg2: Ty1)
	7: Call dynamic_field::borrow_mut<Ty1, Setting<Ty2>>(&mut UID, Ty1): &mut Setting<Ty2>
	8: MutBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	9: Call option::borrow_mut<SettingData<Ty2>>(&mut Option<SettingData<Ty2>>): &mut SettingData<Ty2>
	10: StLoc[4](loc0: &mut SettingData<Ty2>)
	11: CopyLoc[4](loc0: &mut SettingData<Ty2>)
	12: ImmBorrowFieldGeneric[2](SettingData.newer_value_epoch: u64)
	13: ReadRef
	14: MoveLoc[5](loc1: u64)
	15: Eq
	16: BrFalse(18)
B1:
	17: Branch(22)
B2:
	18: MoveLoc[4](loc0: &mut SettingData<Ty2>)
	19: Pop
	20: LdConst[1](u64: 1)
	21: Abort
B3:
	22: CopyLoc[4](loc0: &mut SettingData<Ty2>)
	23: ImmBorrowFieldGeneric[3](SettingData.newer_value: Option<Ty2>)
	24: Call option::is_some<Ty2>(&Option<Ty2>): bool
	25: BrFalse(27)
B4:
	26: Branch(31)
B5:
	27: MoveLoc[4](loc0: &mut SettingData<Ty2>)
	28: Pop
	29: LdConst[1](u64: 1)
	30: Abort
B6:
	31: MoveLoc[4](loc0: &mut SettingData<Ty2>)
	32: MutBorrowFieldGeneric[3](SettingData.newer_value: Option<Ty2>)
	33: Call option::borrow_mut<Ty2>(&mut Option<Ty2>): &mut Ty2
	34: Ret
}

public(friend) read_setting_for_next_epoch<Ty0, Ty1: copy + drop + store, Ty2: copy + drop + store>(Arg0: &Config<Ty0>, Arg1: Ty1): Option<Ty2> {
B0:
	0: CopyLoc[0](Arg0: &Config<Ty0>)
	1: ImmBorrowFieldGeneric[0](Config.id: UID)
	2: CopyLoc[1](Arg1: Ty1)
	3: Call dynamic_field::exists_with_type<Ty1, Setting<Ty2>>(&UID, Ty1): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &Config<Ty0>)
	7: Pop
	8: Call option::none<Ty2>(): Option<Ty2>
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &Config<Ty0>)
	11: ImmBorrowFieldGeneric[0](Config.id: UID)
	12: MoveLoc[1](Arg1: Ty1)
	13: Call dynamic_field::borrow<Ty1, Setting<Ty2>>(&UID, Ty1): &Setting<Ty2>
	14: ImmBorrowFieldGeneric[1](Setting.data: Option<SettingData<Ty2>>)
	15: Call option::borrow<SettingData<Ty2>>(&Option<SettingData<Ty2>>): &SettingData<Ty2>
	16: ImmBorrowFieldGeneric[3](SettingData.newer_value: Option<Ty2>)
	17: ReadRef
	18: Ret
}

public(friend) read_setting<Ty0: copy + drop + store, Ty1: copy + drop + store>(Arg0: ID, Arg1: Ty0, Arg2: &TxContext): Option<Ty1> {
L3:	loc0: address
L4:	loc1: address
B0:
	0: ImmBorrowLoc[0](Arg0: ID)
	1: Call object::id_to_address(&ID): address
	2: StLoc[3](loc0: address)
	3: CopyLoc[3](loc0: address)
	4: MoveLoc[1](Arg1: Ty0)
	5: Call dynamic_field::hash_type_and_key<Ty0>(address, Ty0): address
	6: StLoc[4](loc1: address)
	7: MoveLoc[3](loc0: address)
	8: MoveLoc[4](loc1: address)
	9: MoveLoc[2](Arg2: &TxContext)
	10: Call tx_context::epoch(&TxContext): u64
	11: Call read_setting_impl<Field<Ty0, Setting<Ty1>>, Setting<Ty1>, SettingData<Ty1>, Ty1>(address, address, u64): Option<Ty1>
	12: Ret
}

native read_setting_impl<Ty0: key, Ty1: store, Ty2: store, Ty3: copy + drop + store>(Arg0: address, Arg1: address, Arg2: u64): Option<Ty3>;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
]
}

// Move bytecode v6
module 2.deny_list {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::config;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct DenyList has key {
	id: UID,
	lists: Bag
}

struct ConfigWriteCap has drop {
	dummy_field: bool
}

struct ConfigKey has copy, drop, store {
	per_type_index: u64,
	per_type_key: vector<u8>
}

struct AddressKey has copy, drop, store {
	pos0: address
}

struct GlobalPauseKey has copy, drop, store {
	dummy_field: bool
}

struct PerTypeConfigCreated has copy, drop, store {
	key: ConfigKey,
	config_id: ID
}

struct PerTypeList has store, key {
	id: UID,
	denied_count: Table<address, u64>,
	denied_addresses: Table<vector<u8>, VecSet<address>>
}

public(friend) v2_add(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address, Arg4: &mut TxContext) {
L5:	loc0: ConfigWriteCap
L6:	loc1: &mut ConfigWriteCap
L7:	loc2: &mut Config<ConfigWriteCap>
L8:	loc3: &mut TxContext
L9:	loc4: &mut TxContext
L10:	loc5: &mut DenyList
L11:	loc6: AddressKey
L12:	loc7: &mut bool
L13:	loc8: &mut Config<ConfigWriteCap>
L14:	loc9: u64
L15:	loc10: vector<u8>
L16:	loc11: AddressKey
B0:
	0: MoveLoc[0](Arg0: &mut DenyList)
	1: StLoc[10](loc5: &mut DenyList)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[14](loc9: u64)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: StLoc[15](loc10: vector<u8>)
	6: CopyLoc[4](Arg4: &mut TxContext)
	7: StLoc[8](loc3: &mut TxContext)
	8: CopyLoc[10](loc5: &mut DenyList)
	9: FreezeRef
	10: CopyLoc[14](loc9: u64)
	11: CopyLoc[15](loc10: vector<u8>)
	12: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	13: Not
	14: BrFalse(21)
B1:
	15: CopyLoc[10](loc5: &mut DenyList)
	16: CopyLoc[14](loc9: u64)
	17: CopyLoc[15](loc10: vector<u8>)
	18: MoveLoc[8](loc3: &mut TxContext)
	19: Call add_per_type_config(&mut DenyList, u64, vector<u8>, &mut TxContext)
	20: Branch(23)
B2:
	21: MoveLoc[8](loc3: &mut TxContext)
	22: Pop
B3:
	23: MoveLoc[10](loc5: &mut DenyList)
	24: MoveLoc[14](loc9: u64)
	25: MoveLoc[15](loc10: vector<u8>)
	26: Call borrow_per_type_config_mut(&mut DenyList, u64, vector<u8>): &mut Config<ConfigWriteCap>
	27: StLoc[13](loc8: &mut Config<ConfigWriteCap>)
	28: MoveLoc[3](Arg3: address)
	29: Pack[3](AddressKey)
	30: StLoc[16](loc11: AddressKey)
	31: MoveLoc[13](loc8: &mut Config<ConfigWriteCap>)
	32: StLoc[7](loc2: &mut Config<ConfigWriteCap>)
	33: LdFalse
	34: Pack[1](ConfigWriteCap)
	35: StLoc[5](loc0: ConfigWriteCap)
	36: MutBorrowLoc[5](loc0: ConfigWriteCap)
	37: StLoc[6](loc1: &mut ConfigWriteCap)
	38: MoveLoc[16](loc11: AddressKey)
	39: StLoc[11](loc6: AddressKey)
	40: MoveLoc[4](Arg4: &mut TxContext)
	41: StLoc[9](loc4: &mut TxContext)
	42: CopyLoc[7](loc2: &mut Config<ConfigWriteCap>)
	43: FreezeRef
	44: CopyLoc[11](loc6: AddressKey)
	45: CopyLoc[9](loc4: &mut TxContext)
	46: FreezeRef
	47: Call config::exists_with_type_for_next_epoch<ConfigWriteCap, AddressKey, bool>(&Config<ConfigWriteCap>, AddressKey, &TxContext): bool
	48: Not
	49: BrFalse(63)
B4:
	50: CopyLoc[7](loc2: &mut Config<ConfigWriteCap>)
	51: Pop
	52: CopyLoc[6](loc1: &mut ConfigWriteCap)
	53: Pop
	54: CopyLoc[9](loc4: &mut TxContext)
	55: Pop
	56: CopyLoc[7](loc2: &mut Config<ConfigWriteCap>)
	57: CopyLoc[6](loc1: &mut ConfigWriteCap)
	58: CopyLoc[11](loc6: AddressKey)
	59: LdTrue
	60: CopyLoc[9](loc4: &mut TxContext)
	61: Call config::add_for_next_epoch<ConfigWriteCap, AddressKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, AddressKey, bool, &mut TxContext): Option<bool>
	62: Pop
B5:
	63: MoveLoc[7](loc2: &mut Config<ConfigWriteCap>)
	64: MoveLoc[6](loc1: &mut ConfigWriteCap)
	65: MoveLoc[11](loc6: AddressKey)
	66: MoveLoc[9](loc4: &mut TxContext)
	67: Call config::borrow_for_next_epoch_mut<ConfigWriteCap, AddressKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, AddressKey, &mut TxContext): &mut bool
	68: StLoc[12](loc7: &mut bool)
	69: LdTrue
	70: MoveLoc[12](loc7: &mut bool)
	71: WriteRef
	72: Ret
}

public(friend) v2_remove(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address, Arg4: &mut TxContext) {
L5:	loc0: ConfigWriteCap
L6:	loc1: &mut Config<ConfigWriteCap>
L7:	loc2: &mut TxContext
L8:	loc3: &mut DenyList
L9:	loc4: &mut Config<ConfigWriteCap>
L10:	loc5: u64
L11:	loc6: vector<u8>
L12:	loc7: AddressKey
B0:
	0: MoveLoc[0](Arg0: &mut DenyList)
	1: StLoc[8](loc3: &mut DenyList)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[10](loc5: u64)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: StLoc[11](loc6: vector<u8>)
	6: CopyLoc[4](Arg4: &mut TxContext)
	7: StLoc[7](loc2: &mut TxContext)
	8: CopyLoc[8](loc3: &mut DenyList)
	9: FreezeRef
	10: CopyLoc[10](loc5: u64)
	11: CopyLoc[11](loc6: vector<u8>)
	12: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	13: Not
	14: BrFalse(21)
B1:
	15: CopyLoc[8](loc3: &mut DenyList)
	16: CopyLoc[10](loc5: u64)
	17: CopyLoc[11](loc6: vector<u8>)
	18: MoveLoc[7](loc2: &mut TxContext)
	19: Call add_per_type_config(&mut DenyList, u64, vector<u8>, &mut TxContext)
	20: Branch(23)
B2:
	21: MoveLoc[7](loc2: &mut TxContext)
	22: Pop
B3:
	23: MoveLoc[8](loc3: &mut DenyList)
	24: MoveLoc[10](loc5: u64)
	25: MoveLoc[11](loc6: vector<u8>)
	26: Call borrow_per_type_config_mut(&mut DenyList, u64, vector<u8>): &mut Config<ConfigWriteCap>
	27: StLoc[9](loc4: &mut Config<ConfigWriteCap>)
	28: MoveLoc[3](Arg3: address)
	29: Pack[3](AddressKey)
	30: StLoc[12](loc7: AddressKey)
	31: MoveLoc[9](loc4: &mut Config<ConfigWriteCap>)
	32: StLoc[6](loc1: &mut Config<ConfigWriteCap>)
	33: LdFalse
	34: Pack[1](ConfigWriteCap)
	35: StLoc[5](loc0: ConfigWriteCap)
	36: MoveLoc[6](loc1: &mut Config<ConfigWriteCap>)
	37: MutBorrowLoc[5](loc0: ConfigWriteCap)
	38: MoveLoc[12](loc7: AddressKey)
	39: MoveLoc[4](Arg4: &mut TxContext)
	40: Call config::remove_for_next_epoch<ConfigWriteCap, AddressKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, AddressKey, &mut TxContext): Option<bool>
	41: Pop
	42: Ret
}

public(friend) v2_contains_current_epoch(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address, Arg4: &TxContext): bool {
L5:	loc0: bool
L6:	loc1: Option<bool>
L7:	loc2: &Config<ConfigWriteCap>
L8:	loc3: AddressKey
B0:
	0: CopyLoc[0](Arg0: &DenyList)
	1: CopyLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: vector<u8>)
	3: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	4: Not
	5: BrFalse(12)
B1:
	6: MoveLoc[0](Arg0: &DenyList)
	7: Pop
	8: MoveLoc[4](Arg4: &TxContext)
	9: Pop
	10: LdFalse
	11: Ret
B2:
	12: MoveLoc[0](Arg0: &DenyList)
	13: MoveLoc[1](Arg1: u64)
	14: MoveLoc[2](Arg2: vector<u8>)
	15: Call borrow_per_type_config(&DenyList, u64, vector<u8>): &Config<ConfigWriteCap>
	16: StLoc[7](loc2: &Config<ConfigWriteCap>)
	17: MoveLoc[3](Arg3: address)
	18: Pack[3](AddressKey)
	19: StLoc[8](loc3: AddressKey)
	20: MoveLoc[7](loc2: &Config<ConfigWriteCap>)
	21: Call object::id<Config<ConfigWriteCap>>(&Config<ConfigWriteCap>): ID
	22: MoveLoc[8](loc3: AddressKey)
	23: MoveLoc[4](Arg4: &TxContext)
	24: Call config::read_setting<AddressKey, bool>(ID, AddressKey, &TxContext): Option<bool>
	25: StLoc[6](loc1: Option<bool>)
	26: ImmBorrowLoc[6](loc1: Option<bool>)
	27: Call option::is_some<bool>(&Option<bool>): bool
	28: BrFalse(33)
B3:
	29: MoveLoc[6](loc1: Option<bool>)
	30: Call option::destroy_some<bool>(Option<bool>): bool
	31: StLoc[5](loc0: bool)
	32: Branch(37)
B4:
	33: MoveLoc[6](loc1: Option<bool>)
	34: Call option::destroy_none<bool>(Option<bool>)
	35: LdFalse
	36: StLoc[5](loc0: bool)
B5:
	37: MoveLoc[5](loc0: bool)
	38: Ret
}

public(friend) v2_contains_next_epoch(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address): bool {
L4:	loc0: bool
L5:	loc1: Option<bool>
L6:	loc2: &Config<ConfigWriteCap>
L7:	loc3: AddressKey
B0:
	0: CopyLoc[0](Arg0: &DenyList)
	1: CopyLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: vector<u8>)
	3: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &DenyList)
	7: Pop
	8: LdFalse
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &DenyList)
	11: MoveLoc[1](Arg1: u64)
	12: MoveLoc[2](Arg2: vector<u8>)
	13: Call borrow_per_type_config(&DenyList, u64, vector<u8>): &Config<ConfigWriteCap>
	14: StLoc[6](loc2: &Config<ConfigWriteCap>)
	15: MoveLoc[3](Arg3: address)
	16: Pack[3](AddressKey)
	17: StLoc[7](loc3: AddressKey)
	18: MoveLoc[6](loc2: &Config<ConfigWriteCap>)
	19: MoveLoc[7](loc3: AddressKey)
	20: Call config::read_setting_for_next_epoch<ConfigWriteCap, AddressKey, bool>(&Config<ConfigWriteCap>, AddressKey): Option<bool>
	21: StLoc[5](loc1: Option<bool>)
	22: ImmBorrowLoc[5](loc1: Option<bool>)
	23: Call option::is_some<bool>(&Option<bool>): bool
	24: BrFalse(29)
B3:
	25: MoveLoc[5](loc1: Option<bool>)
	26: Call option::destroy_some<bool>(Option<bool>): bool
	27: StLoc[4](loc0: bool)
	28: Branch(33)
B4:
	29: MoveLoc[5](loc1: Option<bool>)
	30: Call option::destroy_none<bool>(Option<bool>)
	31: LdFalse
	32: StLoc[4](loc0: bool)
B5:
	33: MoveLoc[4](loc0: bool)
	34: Ret
}

public(friend) v2_enable_global_pause(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
L4:	loc0: ConfigWriteCap
L5:	loc1: &mut ConfigWriteCap
L6:	loc2: &mut Config<ConfigWriteCap>
L7:	loc3: &mut TxContext
L8:	loc4: &mut TxContext
L9:	loc5: &mut DenyList
L10:	loc6: GlobalPauseKey
L11:	loc7: &mut bool
L12:	loc8: u64
L13:	loc9: vector<u8>
B0:
	0: MoveLoc[0](Arg0: &mut DenyList)
	1: StLoc[9](loc5: &mut DenyList)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[12](loc8: u64)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: StLoc[13](loc9: vector<u8>)
	6: CopyLoc[3](Arg3: &mut TxContext)
	7: StLoc[7](loc3: &mut TxContext)
	8: CopyLoc[9](loc5: &mut DenyList)
	9: FreezeRef
	10: CopyLoc[12](loc8: u64)
	11: CopyLoc[13](loc9: vector<u8>)
	12: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	13: Not
	14: BrFalse(21)
B1:
	15: CopyLoc[9](loc5: &mut DenyList)
	16: CopyLoc[12](loc8: u64)
	17: CopyLoc[13](loc9: vector<u8>)
	18: MoveLoc[7](loc3: &mut TxContext)
	19: Call add_per_type_config(&mut DenyList, u64, vector<u8>, &mut TxContext)
	20: Branch(23)
B2:
	21: MoveLoc[7](loc3: &mut TxContext)
	22: Pop
B3:
	23: MoveLoc[9](loc5: &mut DenyList)
	24: MoveLoc[12](loc8: u64)
	25: MoveLoc[13](loc9: vector<u8>)
	26: Call borrow_per_type_config_mut(&mut DenyList, u64, vector<u8>): &mut Config<ConfigWriteCap>
	27: StLoc[6](loc2: &mut Config<ConfigWriteCap>)
	28: LdFalse
	29: Pack[1](ConfigWriteCap)
	30: StLoc[4](loc0: ConfigWriteCap)
	31: MutBorrowLoc[4](loc0: ConfigWriteCap)
	32: StLoc[5](loc1: &mut ConfigWriteCap)
	33: LdFalse
	34: Pack[4](GlobalPauseKey)
	35: StLoc[10](loc6: GlobalPauseKey)
	36: MoveLoc[3](Arg3: &mut TxContext)
	37: StLoc[8](loc4: &mut TxContext)
	38: CopyLoc[6](loc2: &mut Config<ConfigWriteCap>)
	39: FreezeRef
	40: CopyLoc[10](loc6: GlobalPauseKey)
	41: CopyLoc[8](loc4: &mut TxContext)
	42: FreezeRef
	43: Call config::exists_with_type_for_next_epoch<ConfigWriteCap, GlobalPauseKey, bool>(&Config<ConfigWriteCap>, GlobalPauseKey, &TxContext): bool
	44: Not
	45: BrFalse(59)
B4:
	46: CopyLoc[6](loc2: &mut Config<ConfigWriteCap>)
	47: Pop
	48: CopyLoc[5](loc1: &mut ConfigWriteCap)
	49: Pop
	50: CopyLoc[8](loc4: &mut TxContext)
	51: Pop
	52: CopyLoc[6](loc2: &mut Config<ConfigWriteCap>)
	53: CopyLoc[5](loc1: &mut ConfigWriteCap)
	54: CopyLoc[10](loc6: GlobalPauseKey)
	55: LdTrue
	56: CopyLoc[8](loc4: &mut TxContext)
	57: Call config::add_for_next_epoch<ConfigWriteCap, GlobalPauseKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, GlobalPauseKey, bool, &mut TxContext): Option<bool>
	58: Pop
B5:
	59: MoveLoc[6](loc2: &mut Config<ConfigWriteCap>)
	60: MoveLoc[5](loc1: &mut ConfigWriteCap)
	61: MoveLoc[10](loc6: GlobalPauseKey)
	62: MoveLoc[8](loc4: &mut TxContext)
	63: Call config::borrow_for_next_epoch_mut<ConfigWriteCap, GlobalPauseKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, GlobalPauseKey, &mut TxContext): &mut bool
	64: StLoc[11](loc7: &mut bool)
	65: LdTrue
	66: MoveLoc[11](loc7: &mut bool)
	67: WriteRef
	68: Ret
}

public(friend) v2_disable_global_pause(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
L4:	loc0: ConfigWriteCap
L5:	loc1: &mut Config<ConfigWriteCap>
L6:	loc2: &mut TxContext
L7:	loc3: &mut DenyList
L8:	loc4: u64
L9:	loc5: vector<u8>
B0:
	0: MoveLoc[0](Arg0: &mut DenyList)
	1: StLoc[7](loc3: &mut DenyList)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[8](loc4: u64)
	4: MoveLoc[2](Arg2: vector<u8>)
	5: StLoc[9](loc5: vector<u8>)
	6: CopyLoc[3](Arg3: &mut TxContext)
	7: StLoc[6](loc2: &mut TxContext)
	8: CopyLoc[7](loc3: &mut DenyList)
	9: FreezeRef
	10: CopyLoc[8](loc4: u64)
	11: CopyLoc[9](loc5: vector<u8>)
	12: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	13: Not
	14: BrFalse(21)
B1:
	15: CopyLoc[7](loc3: &mut DenyList)
	16: CopyLoc[8](loc4: u64)
	17: CopyLoc[9](loc5: vector<u8>)
	18: MoveLoc[6](loc2: &mut TxContext)
	19: Call add_per_type_config(&mut DenyList, u64, vector<u8>, &mut TxContext)
	20: Branch(23)
B2:
	21: MoveLoc[6](loc2: &mut TxContext)
	22: Pop
B3:
	23: MoveLoc[7](loc3: &mut DenyList)
	24: MoveLoc[8](loc4: u64)
	25: MoveLoc[9](loc5: vector<u8>)
	26: Call borrow_per_type_config_mut(&mut DenyList, u64, vector<u8>): &mut Config<ConfigWriteCap>
	27: StLoc[5](loc1: &mut Config<ConfigWriteCap>)
	28: LdFalse
	29: Pack[1](ConfigWriteCap)
	30: StLoc[4](loc0: ConfigWriteCap)
	31: MoveLoc[5](loc1: &mut Config<ConfigWriteCap>)
	32: MutBorrowLoc[4](loc0: ConfigWriteCap)
	33: LdFalse
	34: Pack[4](GlobalPauseKey)
	35: MoveLoc[3](Arg3: &mut TxContext)
	36: Call config::remove_for_next_epoch<ConfigWriteCap, GlobalPauseKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, GlobalPauseKey, &mut TxContext): Option<bool>
	37: Pop
	38: Ret
}

public(friend) v2_is_global_pause_enabled_current_epoch(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: &TxContext): bool {
L4:	loc0: bool
L5:	loc1: Option<bool>
B0:
	0: CopyLoc[0](Arg0: &DenyList)
	1: CopyLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: vector<u8>)
	3: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	4: Not
	5: BrFalse(12)
B1:
	6: MoveLoc[0](Arg0: &DenyList)
	7: Pop
	8: MoveLoc[3](Arg3: &TxContext)
	9: Pop
	10: LdFalse
	11: Ret
B2:
	12: MoveLoc[0](Arg0: &DenyList)
	13: MoveLoc[1](Arg1: u64)
	14: MoveLoc[2](Arg2: vector<u8>)
	15: Call borrow_per_type_config(&DenyList, u64, vector<u8>): &Config<ConfigWriteCap>
	16: Call object::id<Config<ConfigWriteCap>>(&Config<ConfigWriteCap>): ID
	17: LdFalse
	18: Pack[4](GlobalPauseKey)
	19: MoveLoc[3](Arg3: &TxContext)
	20: Call config::read_setting<GlobalPauseKey, bool>(ID, GlobalPauseKey, &TxContext): Option<bool>
	21: StLoc[5](loc1: Option<bool>)
	22: ImmBorrowLoc[5](loc1: Option<bool>)
	23: Call option::is_some<bool>(&Option<bool>): bool
	24: BrFalse(29)
B3:
	25: MoveLoc[5](loc1: Option<bool>)
	26: Call option::destroy_some<bool>(Option<bool>): bool
	27: StLoc[4](loc0: bool)
	28: Branch(33)
B4:
	29: MoveLoc[5](loc1: Option<bool>)
	30: Call option::destroy_none<bool>(Option<bool>)
	31: LdFalse
	32: StLoc[4](loc0: bool)
B5:
	33: MoveLoc[4](loc0: bool)
	34: Ret
}

public(friend) v2_is_global_pause_enabled_next_epoch(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>): bool {
L3:	loc0: bool
L4:	loc1: Option<bool>
B0:
	0: CopyLoc[0](Arg0: &DenyList)
	1: CopyLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: vector<u8>)
	3: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &DenyList)
	7: Pop
	8: LdFalse
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &DenyList)
	11: MoveLoc[1](Arg1: u64)
	12: MoveLoc[2](Arg2: vector<u8>)
	13: Call borrow_per_type_config(&DenyList, u64, vector<u8>): &Config<ConfigWriteCap>
	14: LdFalse
	15: Pack[4](GlobalPauseKey)
	16: Call config::read_setting_for_next_epoch<ConfigWriteCap, GlobalPauseKey, bool>(&Config<ConfigWriteCap>, GlobalPauseKey): Option<bool>
	17: StLoc[4](loc1: Option<bool>)
	18: ImmBorrowLoc[4](loc1: Option<bool>)
	19: Call option::is_some<bool>(&Option<bool>): bool
	20: BrFalse(25)
B3:
	21: MoveLoc[4](loc1: Option<bool>)
	22: Call option::destroy_some<bool>(Option<bool>): bool
	23: StLoc[3](loc0: bool)
	24: Branch(29)
B4:
	25: MoveLoc[4](loc1: Option<bool>)
	26: Call option::destroy_none<bool>(Option<bool>)
	27: LdFalse
	28: StLoc[3](loc0: bool)
B5:
	29: MoveLoc[3](loc0: bool)
	30: Ret
}

public(friend) migrate_v1_to_v2(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: vector<address>
L7:	loc3: ConfigWriteCap
L8:	loc4: address
L9:	loc5: &mut PerTypeList
L10:	loc6: &mut ConfigWriteCap
L11:	loc7: &mut Config<ConfigWriteCap>
L12:	loc8: &mut TxContext
L13:	loc9: &mut TxContext
L14:	loc10: &mut u64
L15:	loc11: &mut DenyList
L16:	loc12: vector<address>
L17:	loc13: u64
L18:	loc14: u64
L19:	loc15: u64
L20:	loc16: AddressKey
L21:	loc17: &mut bool
L22:	loc18: &mut Config<ConfigWriteCap>
L23:	loc19: u64
L24:	loc20: vector<u8>
L25:	loc21: AddressKey
L26:	loc22: u64
L27:	loc23: u64
L28:	loc24: &vector<address>
L29:	loc25: vector<address>
B0:
	0: CopyLoc[0](Arg0: &mut DenyList)
	1: MutBorrowField[0](DenyList.lists: Bag)
	2: CopyLoc[1](Arg1: u64)
	3: Call bag::borrow_mut<u64, PerTypeList>(&mut Bag, u64): &mut PerTypeList
	4: StLoc[9](loc5: &mut PerTypeList)
	5: CopyLoc[9](loc5: &mut PerTypeList)
	6: ImmBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	7: CopyLoc[2](Arg2: vector<u8>)
	8: Call table::contains<vector<u8>, VecSet<address>>(&Table<vector<u8>, VecSet<address>>, vector<u8>): bool
	9: Not
	10: BrFalse(14)
B1:
	11: LdConst[3](vector<address>: 00)
	12: StLoc[6](loc2: vector<address>)
	13: Branch(20)
B2:
	14: CopyLoc[9](loc5: &mut PerTypeList)
	15: MutBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	16: CopyLoc[2](Arg2: vector<u8>)
	17: Call table::remove<vector<u8>, VecSet<address>>(&mut Table<vector<u8>, VecSet<address>>, vector<u8>): VecSet<address>
	18: Call vec_set::into_keys<address>(VecSet<address>): vector<address>
	19: StLoc[6](loc2: vector<address>)
B3:
	20: MoveLoc[6](loc2: vector<address>)
	21: StLoc[16](loc12: vector<address>)
	22: ImmBorrowLoc[16](loc12: vector<address>)
	23: StLoc[28](loc24: &vector<address>)
	24: CopyLoc[28](loc24: &vector<address>)
	25: VecLen(48)
	26: StLoc[5](loc1: u64)
	27: LdU64(0)
	28: StLoc[18](loc14: u64)
	29: MoveLoc[5](loc1: u64)
	30: StLoc[27](loc23: u64)
B4:
	31: CopyLoc[18](loc14: u64)
	32: CopyLoc[27](loc23: u64)
	33: Lt
	34: BrFalse(68)
B5:
	35: CopyLoc[18](loc14: u64)
	36: StLoc[19](loc15: u64)
	37: CopyLoc[28](loc24: &vector<address>)
	38: MoveLoc[19](loc15: u64)
	39: VecImmBorrow(48)
	40: ReadRef
	41: StLoc[8](loc4: address)
	42: CopyLoc[9](loc5: &mut PerTypeList)
	43: MutBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	44: CopyLoc[8](loc4: address)
	45: Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
	46: StLoc[14](loc10: &mut u64)
	47: CopyLoc[14](loc10: &mut u64)
	48: ReadRef
	49: LdU64(1)
	50: Sub
	51: CopyLoc[14](loc10: &mut u64)
	52: WriteRef
	53: MoveLoc[14](loc10: &mut u64)
	54: ReadRef
	55: LdU64(0)
	56: Eq
	57: BrFalse(63)
B6:
	58: CopyLoc[9](loc5: &mut PerTypeList)
	59: MutBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	60: MoveLoc[8](loc4: address)
	61: Call table::remove<address, u64>(&mut Table<address, u64>, address): u64
	62: Pop
B7:
	63: MoveLoc[18](loc14: u64)
	64: LdU64(1)
	65: Add
	66: StLoc[18](loc14: u64)
	67: Branch(31)
B8:
	68: MoveLoc[28](loc24: &vector<address>)
	69: Pop
	70: MoveLoc[9](loc5: &mut PerTypeList)
	71: Pop
	72: MoveLoc[0](Arg0: &mut DenyList)
	73: StLoc[15](loc11: &mut DenyList)
	74: MoveLoc[1](Arg1: u64)
	75: StLoc[23](loc19: u64)
	76: MoveLoc[2](Arg2: vector<u8>)
	77: StLoc[24](loc20: vector<u8>)
	78: CopyLoc[3](Arg3: &mut TxContext)
	79: StLoc[12](loc8: &mut TxContext)
	80: CopyLoc[15](loc11: &mut DenyList)
	81: FreezeRef
	82: CopyLoc[23](loc19: u64)
	83: CopyLoc[24](loc20: vector<u8>)
	84: Call per_type_exists(&DenyList, u64, vector<u8>): bool
	85: Not
	86: BrFalse(94)
B9:
	87: Branch(88)
B10:
	88: CopyLoc[15](loc11: &mut DenyList)
	89: CopyLoc[23](loc19: u64)
	90: CopyLoc[24](loc20: vector<u8>)
	91: MoveLoc[12](loc8: &mut TxContext)
	92: Call add_per_type_config(&mut DenyList, u64, vector<u8>, &mut TxContext)
	93: Branch(96)
B11:
	94: MoveLoc[12](loc8: &mut TxContext)
	95: Pop
B12:
	96: MoveLoc[15](loc11: &mut DenyList)
	97: MoveLoc[23](loc19: u64)
	98: MoveLoc[24](loc20: vector<u8>)
	99: Call borrow_per_type_config_mut(&mut DenyList, u64, vector<u8>): &mut Config<ConfigWriteCap>
	100: StLoc[22](loc18: &mut Config<ConfigWriteCap>)
	101: MoveLoc[16](loc12: vector<address>)
	102: StLoc[29](loc25: vector<address>)
	103: MutBorrowLoc[29](loc25: vector<address>)
	104: Call vector::reverse<address>(&mut vector<address>)
	105: ImmBorrowLoc[29](loc25: vector<address>)
	106: VecLen(48)
	107: StLoc[4](loc0: u64)
	108: LdU64(0)
	109: StLoc[17](loc13: u64)
	110: MoveLoc[4](loc0: u64)
	111: StLoc[26](loc22: u64)
B13:
	112: CopyLoc[17](loc13: u64)
	113: CopyLoc[26](loc22: u64)
	114: Lt
	115: BrFalse(168)
B14:
	116: CopyLoc[17](loc13: u64)
	117: Pop
	118: MutBorrowLoc[29](loc25: vector<address>)
	119: VecPopBack(48)
	120: Pack[3](AddressKey)
	121: StLoc[25](loc21: AddressKey)
	122: CopyLoc[22](loc18: &mut Config<ConfigWriteCap>)
	123: StLoc[11](loc7: &mut Config<ConfigWriteCap>)
	124: LdFalse
	125: Pack[1](ConfigWriteCap)
	126: StLoc[7](loc3: ConfigWriteCap)
	127: MutBorrowLoc[7](loc3: ConfigWriteCap)
	128: StLoc[10](loc6: &mut ConfigWriteCap)
	129: MoveLoc[25](loc21: AddressKey)
	130: StLoc[20](loc16: AddressKey)
	131: CopyLoc[3](Arg3: &mut TxContext)
	132: StLoc[13](loc9: &mut TxContext)
	133: CopyLoc[11](loc7: &mut Config<ConfigWriteCap>)
	134: FreezeRef
	135: CopyLoc[20](loc16: AddressKey)
	136: CopyLoc[13](loc9: &mut TxContext)
	137: FreezeRef
	138: Call config::exists_with_type_for_next_epoch<ConfigWriteCap, AddressKey, bool>(&Config<ConfigWriteCap>, AddressKey, &TxContext): bool
	139: Not
	140: BrFalse(154)
B15:
	141: CopyLoc[11](loc7: &mut Config<ConfigWriteCap>)
	142: Pop
	143: CopyLoc[10](loc6: &mut ConfigWriteCap)
	144: Pop
	145: CopyLoc[13](loc9: &mut TxContext)
	146: Pop
	147: CopyLoc[11](loc7: &mut Config<ConfigWriteCap>)
	148: CopyLoc[10](loc6: &mut ConfigWriteCap)
	149: CopyLoc[20](loc16: AddressKey)
	150: LdTrue
	151: CopyLoc[13](loc9: &mut TxContext)
	152: Call config::add_for_next_epoch<ConfigWriteCap, AddressKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, AddressKey, bool, &mut TxContext): Option<bool>
	153: Pop
B16:
	154: MoveLoc[11](loc7: &mut Config<ConfigWriteCap>)
	155: MoveLoc[10](loc6: &mut ConfigWriteCap)
	156: MoveLoc[20](loc16: AddressKey)
	157: MoveLoc[13](loc9: &mut TxContext)
	158: Call config::borrow_for_next_epoch_mut<ConfigWriteCap, AddressKey, bool>(&mut Config<ConfigWriteCap>, &mut ConfigWriteCap, AddressKey, &mut TxContext): &mut bool
	159: StLoc[21](loc17: &mut bool)
	160: LdTrue
	161: MoveLoc[21](loc17: &mut bool)
	162: WriteRef
	163: MoveLoc[17](loc13: u64)
	164: LdU64(1)
	165: Add
	166: StLoc[17](loc13: u64)
	167: Branch(112)
B17:
	168: MoveLoc[22](loc18: &mut Config<ConfigWriteCap>)
	169: Pop
	170: MoveLoc[3](Arg3: &mut TxContext)
	171: Pop
	172: MoveLoc[29](loc25: vector<address>)
	173: VecUnpack(48, 0)
	174: Ret
}

add_per_type_config(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
L4:	loc0: ConfigWriteCap
L5:	loc1: Config<ConfigWriteCap>
L6:	loc2: ID
L7:	loc3: ConfigKey
B0:
	0: MoveLoc[1](Arg1: u64)
	1: MoveLoc[2](Arg2: vector<u8>)
	2: Pack[2](ConfigKey)
	3: StLoc[7](loc3: ConfigKey)
	4: LdFalse
	5: Pack[1](ConfigWriteCap)
	6: StLoc[4](loc0: ConfigWriteCap)
	7: MutBorrowLoc[4](loc0: ConfigWriteCap)
	8: MoveLoc[3](Arg3: &mut TxContext)
	9: Call config::new<ConfigWriteCap>(&mut ConfigWriteCap, &mut TxContext): Config<ConfigWriteCap>
	10: StLoc[5](loc1: Config<ConfigWriteCap>)
	11: ImmBorrowLoc[5](loc1: Config<ConfigWriteCap>)
	12: Call object::id<Config<ConfigWriteCap>>(&Config<ConfigWriteCap>): ID
	13: StLoc[6](loc2: ID)
	14: MoveLoc[0](Arg0: &mut DenyList)
	15: MutBorrowField[3](DenyList.id: UID)
	16: CopyLoc[7](loc3: ConfigKey)
	17: MoveLoc[5](loc1: Config<ConfigWriteCap>)
	18: Call dynamic_object_field::internal_add<ConfigKey, Config<ConfigWriteCap>>(&mut UID, ConfigKey, Config<ConfigWriteCap>)
	19: MoveLoc[7](loc3: ConfigKey)
	20: MoveLoc[6](loc2: ID)
	21: Pack[5](PerTypeConfigCreated)
	22: Call event::emit<PerTypeConfigCreated>(PerTypeConfigCreated)
	23: Ret
}

borrow_per_type_config_mut(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>): &mut Config<ConfigWriteCap> {
L3:	loc0: ConfigKey
B0:
	0: MoveLoc[1](Arg1: u64)
	1: MoveLoc[2](Arg2: vector<u8>)
	2: Pack[2](ConfigKey)
	3: StLoc[3](loc0: ConfigKey)
	4: MoveLoc[0](Arg0: &mut DenyList)
	5: MutBorrowField[3](DenyList.id: UID)
	6: MoveLoc[3](loc0: ConfigKey)
	7: Call dynamic_object_field::internal_borrow_mut<ConfigKey, Config<ConfigWriteCap>>(&mut UID, ConfigKey): &mut Config<ConfigWriteCap>
	8: Ret
}

borrow_per_type_config(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>): &Config<ConfigWriteCap> {
L3:	loc0: ConfigKey
B0:
	0: MoveLoc[1](Arg1: u64)
	1: MoveLoc[2](Arg2: vector<u8>)
	2: Pack[2](ConfigKey)
	3: StLoc[3](loc0: ConfigKey)
	4: MoveLoc[0](Arg0: &DenyList)
	5: ImmBorrowField[3](DenyList.id: UID)
	6: MoveLoc[3](loc0: ConfigKey)
	7: Call dynamic_object_field::internal_borrow<ConfigKey, Config<ConfigWriteCap>>(&UID, ConfigKey): &Config<ConfigWriteCap>
	8: Ret
}

per_type_exists(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>): bool {
L3:	loc0: ConfigKey
B0:
	0: MoveLoc[1](Arg1: u64)
	1: MoveLoc[2](Arg2: vector<u8>)
	2: Pack[2](ConfigKey)
	3: StLoc[3](loc0: ConfigKey)
	4: MoveLoc[0](Arg0: &DenyList)
	5: ImmBorrowField[3](DenyList.id: UID)
	6: MoveLoc[3](loc0: ConfigKey)
	7: Call dynamic_object_field::exists_<ConfigKey>(&UID, ConfigKey): bool
	8: Ret
}

public(friend) v1_add(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address) {
L4:	loc0: vector<address>
B0:
	0: LdConst[2](vector<address>: 1200..)
	1: StLoc[4](loc0: vector<address>)
	2: ImmBorrowLoc[4](loc0: vector<address>)
	3: ImmBorrowLoc[3](Arg3: address)
	4: Call vector::contains<address>(&vector<address>, &address): bool
	5: Not
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[0](Arg0: &mut DenyList)
	9: Pop
	10: LdConst[1](u64: 1)
	11: Abort
B3:
	12: MoveLoc[0](Arg0: &mut DenyList)
	13: MutBorrowField[0](DenyList.lists: Bag)
	14: MoveLoc[1](Arg1: u64)
	15: Call bag::borrow_mut<u64, PerTypeList>(&mut Bag, u64): &mut PerTypeList
	16: MoveLoc[2](Arg2: vector<u8>)
	17: MoveLoc[3](Arg3: address)
	18: Call v1_per_type_list_add(&mut PerTypeList, vector<u8>, address)
	19: Ret
}

v1_per_type_list_add(Arg0: &mut PerTypeList, Arg1: vector<u8>, Arg2: address) {
L3:	loc0: &mut VecSet<address>
L4:	loc1: &mut u64
B0:
	0: CopyLoc[0](Arg0: &mut PerTypeList)
	1: ImmBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	2: CopyLoc[1](Arg1: vector<u8>)
	3: Call table::contains<vector<u8>, VecSet<address>>(&Table<vector<u8>, VecSet<address>>, vector<u8>): bool
	4: Not
	5: BrFalse(11)
B1:
	6: CopyLoc[0](Arg0: &mut PerTypeList)
	7: MutBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	8: CopyLoc[1](Arg1: vector<u8>)
	9: Call vec_set::empty<address>(): VecSet<address>
	10: Call table::add<vector<u8>, VecSet<address>>(&mut Table<vector<u8>, VecSet<address>>, vector<u8>, VecSet<address>)
B2:
	11: CopyLoc[0](Arg0: &mut PerTypeList)
	12: MutBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	13: MoveLoc[1](Arg1: vector<u8>)
	14: Call table::borrow_mut<vector<u8>, VecSet<address>>(&mut Table<vector<u8>, VecSet<address>>, vector<u8>): &mut VecSet<address>
	15: StLoc[3](loc0: &mut VecSet<address>)
	16: CopyLoc[3](loc0: &mut VecSet<address>)
	17: FreezeRef
	18: ImmBorrowLoc[2](Arg2: address)
	19: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	20: BrFalse(26)
B3:
	21: MoveLoc[0](Arg0: &mut PerTypeList)
	22: Pop
	23: MoveLoc[3](loc0: &mut VecSet<address>)
	24: Pop
	25: Ret
B4:
	26: MoveLoc[3](loc0: &mut VecSet<address>)
	27: CopyLoc[2](Arg2: address)
	28: Call vec_set::insert<address>(&mut VecSet<address>, address)
	29: CopyLoc[0](Arg0: &mut PerTypeList)
	30: ImmBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	31: CopyLoc[2](Arg2: address)
	32: Call table::contains<address, u64>(&Table<address, u64>, address): bool
	33: Not
	34: BrFalse(40)
B5:
	35: CopyLoc[0](Arg0: &mut PerTypeList)
	36: MutBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	37: CopyLoc[2](Arg2: address)
	38: LdU64(0)
	39: Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
B6:
	40: MoveLoc[0](Arg0: &mut PerTypeList)
	41: MutBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	42: MoveLoc[2](Arg2: address)
	43: Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
	44: StLoc[4](loc1: &mut u64)
	45: CopyLoc[4](loc1: &mut u64)
	46: ReadRef
	47: LdU64(1)
	48: Add
	49: MoveLoc[4](loc1: &mut u64)
	50: WriteRef
	51: Ret
}

public(friend) v1_remove(Arg0: &mut DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address) {
L4:	loc0: vector<address>
B0:
	0: LdConst[2](vector<address>: 1200..)
	1: StLoc[4](loc0: vector<address>)
	2: ImmBorrowLoc[4](loc0: vector<address>)
	3: ImmBorrowLoc[3](Arg3: address)
	4: Call vector::contains<address>(&vector<address>, &address): bool
	5: Not
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[0](Arg0: &mut DenyList)
	9: Pop
	10: LdConst[1](u64: 1)
	11: Abort
B3:
	12: MoveLoc[0](Arg0: &mut DenyList)
	13: MutBorrowField[0](DenyList.lists: Bag)
	14: MoveLoc[1](Arg1: u64)
	15: Call bag::borrow_mut<u64, PerTypeList>(&mut Bag, u64): &mut PerTypeList
	16: MoveLoc[2](Arg2: vector<u8>)
	17: MoveLoc[3](Arg3: address)
	18: Call v1_per_type_list_remove(&mut PerTypeList, vector<u8>, address)
	19: Ret
}

v1_per_type_list_remove(Arg0: &mut PerTypeList, Arg1: vector<u8>, Arg2: address) {
L3:	loc0: &mut VecSet<address>
L4:	loc1: &mut u64
B0:
	0: CopyLoc[0](Arg0: &mut PerTypeList)
	1: MutBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	2: MoveLoc[1](Arg1: vector<u8>)
	3: Call table::borrow_mut<vector<u8>, VecSet<address>>(&mut Table<vector<u8>, VecSet<address>>, vector<u8>): &mut VecSet<address>
	4: StLoc[3](loc0: &mut VecSet<address>)
	5: CopyLoc[3](loc0: &mut VecSet<address>)
	6: FreezeRef
	7: ImmBorrowLoc[2](Arg2: address)
	8: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	9: BrFalse(11)
B1:
	10: Branch(17)
B2:
	11: MoveLoc[0](Arg0: &mut PerTypeList)
	12: Pop
	13: MoveLoc[3](loc0: &mut VecSet<address>)
	14: Pop
	15: LdConst[1](u64: 1)
	16: Abort
B3:
	17: MoveLoc[3](loc0: &mut VecSet<address>)
	18: ImmBorrowLoc[2](Arg2: address)
	19: Call vec_set::remove<address>(&mut VecSet<address>, &address)
	20: CopyLoc[0](Arg0: &mut PerTypeList)
	21: MutBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	22: CopyLoc[2](Arg2: address)
	23: Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
	24: StLoc[4](loc1: &mut u64)
	25: CopyLoc[4](loc1: &mut u64)
	26: ReadRef
	27: LdU64(1)
	28: Sub
	29: CopyLoc[4](loc1: &mut u64)
	30: WriteRef
	31: MoveLoc[4](loc1: &mut u64)
	32: ReadRef
	33: LdU64(0)
	34: Eq
	35: BrFalse(42)
B4:
	36: MoveLoc[0](Arg0: &mut PerTypeList)
	37: MutBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	38: MoveLoc[2](Arg2: address)
	39: Call table::remove<address, u64>(&mut Table<address, u64>, address): u64
	40: Pop
	41: Branch(44)
B5:
	42: MoveLoc[0](Arg0: &mut PerTypeList)
	43: Pop
B6:
	44: Ret
}

public(friend) v1_contains(Arg0: &DenyList, Arg1: u64, Arg2: vector<u8>, Arg3: address): bool {
L4:	loc0: vector<address>
B0:
	0: LdConst[2](vector<address>: 1200..)
	1: StLoc[4](loc0: vector<address>)
	2: ImmBorrowLoc[4](loc0: vector<address>)
	3: ImmBorrowLoc[3](Arg3: address)
	4: Call vector::contains<address>(&vector<address>, &address): bool
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &DenyList)
	7: Pop
	8: LdFalse
	9: Ret
B2:
	10: MoveLoc[0](Arg0: &DenyList)
	11: ImmBorrowField[0](DenyList.lists: Bag)
	12: MoveLoc[1](Arg1: u64)
	13: Call bag::borrow<u64, PerTypeList>(&Bag, u64): &PerTypeList
	14: MoveLoc[2](Arg2: vector<u8>)
	15: MoveLoc[3](Arg3: address)
	16: Call v1_per_type_list_contains(&PerTypeList, vector<u8>, address): bool
	17: Ret
}

v1_per_type_list_contains(Arg0: &PerTypeList, Arg1: vector<u8>, Arg2: address): bool {
B0:
	0: CopyLoc[0](Arg0: &PerTypeList)
	1: ImmBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	2: CopyLoc[2](Arg2: address)
	3: Call table::contains<address, u64>(&Table<address, u64>, address): bool
	4: Not
	5: BrFalse(10)
B1:
	6: MoveLoc[0](Arg0: &PerTypeList)
	7: Pop
	8: LdFalse
	9: Ret
B2:
	10: CopyLoc[0](Arg0: &PerTypeList)
	11: ImmBorrowField[2](PerTypeList.denied_count: Table<address, u64>)
	12: CopyLoc[2](Arg2: address)
	13: Call table::borrow<address, u64>(&Table<address, u64>, address): &u64
	14: ReadRef
	15: LdU64(0)
	16: Eq
	17: BrFalse(22)
B3:
	18: MoveLoc[0](Arg0: &PerTypeList)
	19: Pop
	20: LdFalse
	21: Ret
B4:
	22: CopyLoc[0](Arg0: &PerTypeList)
	23: ImmBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	24: CopyLoc[1](Arg1: vector<u8>)
	25: Call table::contains<vector<u8>, VecSet<address>>(&Table<vector<u8>, VecSet<address>>, vector<u8>): bool
	26: Not
	27: BrFalse(32)
B5:
	28: MoveLoc[0](Arg0: &PerTypeList)
	29: Pop
	30: LdFalse
	31: Ret
B6:
	32: MoveLoc[0](Arg0: &PerTypeList)
	33: ImmBorrowField[1](PerTypeList.denied_addresses: Table<vector<u8>, VecSet<address>>)
	34: MoveLoc[1](Arg1: vector<u8>)
	35: Call table::borrow<vector<u8>, VecSet<address>>(&Table<vector<u8>, VecSet<address>>, vector<u8>): &VecSet<address>
	36: ImmBorrowLoc[2](Arg2: address)
	37: Call vec_set::contains<address>(&VecSet<address>, &address): bool
	38: Ret
}

create(Arg0: &mut TxContext) {
L1:	loc0: Bag
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: LdConst[4](address: 0x00..)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut TxContext)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut TxContext)
	12: Call bag::new(&mut TxContext): Bag
	13: StLoc[1](loc0: Bag)
	14: MutBorrowLoc[1](loc0: Bag)
	15: LdConst[0](u64: 0)
	16: MoveLoc[0](Arg0: &mut TxContext)
	17: Call per_type_list(&mut TxContext): PerTypeList
	18: Call bag::add<u64, PerTypeList>(&mut Bag, u64, PerTypeList)
	19: Call object::safe_deny_list_object_id(): UID
	20: MoveLoc[1](loc0: Bag)
	21: Pack[0](DenyList)
	22: Call transfer::share_object<DenyList>(DenyList)
	23: Ret
}

per_type_list(Arg0: &mut TxContext): PerTypeList {
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: CopyLoc[0](Arg0: &mut TxContext)
	3: Call table::new<address, u64>(&mut TxContext): Table<address, u64>
	4: MoveLoc[0](Arg0: &mut TxContext)
	5: Call table::new<vector<u8>, VecSet<address>>(&mut TxContext): Table<vector<u8>, VecSet<address>>
	6: Pack[6](PerTypeList)
	7: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => vector<address>: 120000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000f0000000000000000000000000000000000000000000000000000000000000403000000000000000000000000000000000000000000000000000000000000dee9
	3 => vector<address>: 00
	4 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 2.display {
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct Display<phantom Ty0: key> has store, key {
	id: UID,
	fields: VecMap<String, String>,
	version: u16
}

struct DisplayCreated<phantom Ty0: key> has copy, drop {
	id: ID
}

struct VersionUpdated<phantom Ty0: key> has copy, drop {
	id: ID,
	version: u16,
	fields: VecMap<String, String>
}

public new<Ty0: key>(Arg0: &Publisher, Arg1: &mut TxContext): Display<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: Call is_authorized<Ty0>(&Publisher): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[1](Arg1: &mut TxContext)
	5: Pop
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: MoveLoc[1](Arg1: &mut TxContext)
	9: Call create_internal<Ty0>(&mut TxContext): Display<Ty0>
	10: Ret
}

public new_with_fields<Ty0: key>(Arg0: &Publisher, Arg1: vector<String>, Arg2: vector<String>, Arg3: &mut TxContext): Display<Ty0> {
L4:	loc0: u64
L5:	loc1: Display<Ty0>
L6:	loc2: String
L7:	loc3: u64
L8:	loc4: u64
L9:	loc5: vector<String>
L10:	loc6: vector<String>
L11:	loc7: vector<String>
L12:	loc8: String
B0:
	0: ImmBorrowLoc[1](Arg1: vector<String>)
	1: VecLen(16)
	2: ImmBorrowLoc[2](Arg2: vector<String>)
	3: VecLen(16)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(13)
B2:
	7: MoveLoc[0](Arg0: &Publisher)
	8: Pop
	9: MoveLoc[3](Arg3: &mut TxContext)
	10: Pop
	11: LdConst[1](u64: 1)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &Publisher)
	14: MoveLoc[3](Arg3: &mut TxContext)
	15: Call new<Ty0>(&Publisher, &mut TxContext): Display<Ty0>
	16: StLoc[5](loc1: Display<Ty0>)
	17: MoveLoc[1](Arg1: vector<String>)
	18: StLoc[10](loc6: vector<String>)
	19: MoveLoc[2](Arg2: vector<String>)
	20: StLoc[11](loc7: vector<String>)
	21: MutBorrowLoc[11](loc7: vector<String>)
	22: Call vector::reverse<String>(&mut vector<String>)
	23: ImmBorrowLoc[10](loc6: vector<String>)
	24: VecLen(16)
	25: ImmBorrowLoc[11](loc7: vector<String>)
	26: VecLen(16)
	27: Eq
	28: BrFalse(30)
B4:
	29: Branch(32)
B5:
	30: LdU64(13906834586660241407)
	31: Abort
B6:
	32: MoveLoc[10](loc6: vector<String>)
	33: StLoc[9](loc5: vector<String>)
	34: MutBorrowLoc[9](loc5: vector<String>)
	35: Call vector::reverse<String>(&mut vector<String>)
	36: ImmBorrowLoc[9](loc5: vector<String>)
	37: VecLen(16)
	38: StLoc[4](loc0: u64)
	39: LdU64(0)
	40: StLoc[7](loc3: u64)
	41: MoveLoc[4](loc0: u64)
	42: StLoc[8](loc4: u64)
B7:
	43: CopyLoc[7](loc3: u64)
	44: CopyLoc[8](loc4: u64)
	45: Lt
	46: BrFalse(64)
B8:
	47: CopyLoc[7](loc3: u64)
	48: Pop
	49: MutBorrowLoc[9](loc5: vector<String>)
	50: VecPopBack(16)
	51: StLoc[6](loc2: String)
	52: MutBorrowLoc[11](loc7: vector<String>)
	53: VecPopBack(16)
	54: StLoc[12](loc8: String)
	55: MutBorrowLoc[5](loc1: Display<Ty0>)
	56: MoveLoc[6](loc2: String)
	57: MoveLoc[12](loc8: String)
	58: Call add_internal<Ty0>(&mut Display<Ty0>, String, String)
	59: MoveLoc[7](loc3: u64)
	60: LdU64(1)
	61: Add
	62: StLoc[7](loc3: u64)
	63: Branch(43)
B9:
	64: MoveLoc[9](loc5: vector<String>)
	65: VecUnpack(16, 0)
	66: MoveLoc[11](loc7: vector<String>)
	67: VecUnpack(16, 0)
	68: MoveLoc[5](loc1: Display<Ty0>)
	69: Ret
}

entry public create_and_keep<Ty0: key>(Arg0: &Publisher, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: CopyLoc[1](Arg1: &mut TxContext)
	2: Call new<Ty0>(&Publisher, &mut TxContext): Display<Ty0>
	3: MoveLoc[1](Arg1: &mut TxContext)
	4: FreezeRef
	5: Call tx_context::sender(&TxContext): address
	6: Call transfer::public_transfer<Display<Ty0>>(Display<Ty0>, address)
	7: Ret
}

entry public update_version<Ty0: key>(Arg0: &mut Display<Ty0>) {
L1:	loc0: u16
L2:	loc1: VecMap<String, String>
B0:
	0: CopyLoc[0](Arg0: &mut Display<Ty0>)
	1: ImmBorrowFieldGeneric[0](Display.version: u16)
	2: ReadRef
	3: LdU16(1)
	4: Add
	5: CopyLoc[0](Arg0: &mut Display<Ty0>)
	6: MutBorrowFieldGeneric[0](Display.version: u16)
	7: WriteRef
	8: CopyLoc[0](Arg0: &mut Display<Ty0>)
	9: ImmBorrowFieldGeneric[0](Display.version: u16)
	10: ReadRef
	11: StLoc[1](loc0: u16)
	12: CopyLoc[0](Arg0: &mut Display<Ty0>)
	13: ImmBorrowFieldGeneric[1](Display.fields: VecMap<String, String>)
	14: ReadRef
	15: StLoc[2](loc1: VecMap<String, String>)
	16: MoveLoc[0](Arg0: &mut Display<Ty0>)
	17: ImmBorrowFieldGeneric[2](Display.id: UID)
	18: Call object::uid_to_inner(&UID): ID
	19: MoveLoc[1](loc0: u16)
	20: MoveLoc[2](loc1: VecMap<String, String>)
	21: PackGeneric[0](VersionUpdated<Ty0>)
	22: Call event::emit<VersionUpdated<Ty0>>(VersionUpdated<Ty0>)
	23: Ret
}

entry public add<Ty0: key>(Arg0: &mut Display<Ty0>, Arg1: String, Arg2: String) {
B0:
	0: MoveLoc[0](Arg0: &mut Display<Ty0>)
	1: MoveLoc[1](Arg1: String)
	2: MoveLoc[2](Arg2: String)
	3: Call add_internal<Ty0>(&mut Display<Ty0>, String, String)
	4: Ret
}

entry public add_multiple<Ty0: key>(Arg0: &mut Display<Ty0>, Arg1: vector<String>, Arg2: vector<String>) {
L3:	loc0: u64
L4:	loc1: String
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: vector<String>
L8:	loc5: vector<String>
L9:	loc6: vector<String>
L10:	loc7: String
B0:
	0: ImmBorrowLoc[1](Arg1: vector<String>)
	1: VecLen(16)
	2: ImmBorrowLoc[2](Arg2: vector<String>)
	3: VecLen(16)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut Display<Ty0>)
	8: Pop
	9: LdConst[1](u64: 1)
	10: Abort
B3:
	11: MoveLoc[1](Arg1: vector<String>)
	12: StLoc[8](loc5: vector<String>)
	13: MoveLoc[2](Arg2: vector<String>)
	14: StLoc[9](loc6: vector<String>)
	15: MutBorrowLoc[9](loc6: vector<String>)
	16: Call vector::reverse<String>(&mut vector<String>)
	17: ImmBorrowLoc[8](loc5: vector<String>)
	18: VecLen(16)
	19: ImmBorrowLoc[9](loc6: vector<String>)
	20: VecLen(16)
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[0](Arg0: &mut Display<Ty0>)
	25: Pop
	26: LdU64(13906834758458933247)
	27: Abort
B6:
	28: MoveLoc[8](loc5: vector<String>)
	29: StLoc[7](loc4: vector<String>)
	30: MutBorrowLoc[7](loc4: vector<String>)
	31: Call vector::reverse<String>(&mut vector<String>)
	32: ImmBorrowLoc[7](loc4: vector<String>)
	33: VecLen(16)
	34: StLoc[3](loc0: u64)
	35: LdU64(0)
	36: StLoc[5](loc2: u64)
	37: MoveLoc[3](loc0: u64)
	38: StLoc[6](loc3: u64)
B7:
	39: CopyLoc[5](loc2: u64)
	40: CopyLoc[6](loc3: u64)
	41: Lt
	42: BrFalse(60)
B8:
	43: CopyLoc[5](loc2: u64)
	44: Pop
	45: MutBorrowLoc[7](loc4: vector<String>)
	46: VecPopBack(16)
	47: StLoc[4](loc1: String)
	48: MutBorrowLoc[9](loc6: vector<String>)
	49: VecPopBack(16)
	50: StLoc[10](loc7: String)
	51: CopyLoc[0](Arg0: &mut Display<Ty0>)
	52: MoveLoc[4](loc1: String)
	53: MoveLoc[10](loc7: String)
	54: Call add_internal<Ty0>(&mut Display<Ty0>, String, String)
	55: MoveLoc[5](loc2: u64)
	56: LdU64(1)
	57: Add
	58: StLoc[5](loc2: u64)
	59: Branch(39)
B9:
	60: MoveLoc[0](Arg0: &mut Display<Ty0>)
	61: Pop
	62: MoveLoc[7](loc4: vector<String>)
	63: VecUnpack(16, 0)
	64: MoveLoc[9](loc6: vector<String>)
	65: VecUnpack(16, 0)
	66: Ret
}

entry public edit<Ty0: key>(Arg0: &mut Display<Ty0>, Arg1: String, Arg2: String) {
B0:
	0: CopyLoc[0](Arg0: &mut Display<Ty0>)
	1: MutBorrowFieldGeneric[1](Display.fields: VecMap<String, String>)
	2: ImmBorrowLoc[1](Arg1: String)
	3: Call vec_map::remove<String, String>(&mut VecMap<String, String>, &String): String * String
	4: Pop
	5: Pop
	6: MoveLoc[0](Arg0: &mut Display<Ty0>)
	7: MoveLoc[1](Arg1: String)
	8: MoveLoc[2](Arg2: String)
	9: Call add_internal<Ty0>(&mut Display<Ty0>, String, String)
	10: Ret
}

entry public remove<Ty0: key>(Arg0: &mut Display<Ty0>, Arg1: String) {
B0:
	0: MoveLoc[0](Arg0: &mut Display<Ty0>)
	1: MutBorrowFieldGeneric[1](Display.fields: VecMap<String, String>)
	2: ImmBorrowLoc[1](Arg1: String)
	3: Call vec_map::remove<String, String>(&mut VecMap<String, String>, &String): String * String
	4: Pop
	5: Pop
	6: Ret
}

public is_authorized<Ty0: key>(Arg0: &Publisher): bool {
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: Call package::from_package<Ty0>(&Publisher): bool
	2: Ret
}

public version<Ty0: key>(Arg0: &Display<Ty0>): u16 {
B0:
	0: MoveLoc[0](Arg0: &Display<Ty0>)
	1: ImmBorrowFieldGeneric[0](Display.version: u16)
	2: ReadRef
	3: Ret
}

public fields<Ty0: key>(Arg0: &Display<Ty0>): &VecMap<String, String> {
B0:
	0: MoveLoc[0](Arg0: &Display<Ty0>)
	1: ImmBorrowFieldGeneric[1](Display.fields: VecMap<String, String>)
	2: Ret
}

create_internal<Ty0: key>(Arg0: &mut TxContext): Display<Ty0> {
L1:	loc0: UID
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: StLoc[1](loc0: UID)
	3: ImmBorrowLoc[1](loc0: UID)
	4: Call object::uid_to_inner(&UID): ID
	5: PackGeneric[1](DisplayCreated<Ty0>)
	6: Call event::emit<DisplayCreated<Ty0>>(DisplayCreated<Ty0>)
	7: MoveLoc[1](loc0: UID)
	8: Call vec_map::empty<String, String>(): VecMap<String, String>
	9: LdU16(0)
	10: PackGeneric[2](Display<Ty0>)
	11: Ret
}

add_internal<Ty0: key>(Arg0: &mut Display<Ty0>, Arg1: String, Arg2: String) {
B0:
	0: MoveLoc[0](Arg0: &mut Display<Ty0>)
	1: MutBorrowFieldGeneric[1](Display.fields: VecMap<String, String>)
	2: MoveLoc[1](Arg1: String)
	3: MoveLoc[2](Arg2: String)
	4: Call vec_map::insert<String, String>(&mut VecMap<String, String>, String, String)
	5: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
]
}

// Move bytecode v6
module 2.dynamic_field {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct Field<Ty0: copy + drop + store, Ty1: store> has key {
	id: UID,
	name: Ty0,
	value: Ty1
}

public add<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0, Arg2: Ty1) {
L3:	loc0: Field<Ty0, Ty1>
L4:	loc1: address
L5:	loc2: address
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: FreezeRef
	2: Call object::uid_to_address(&UID): address
	3: StLoc[5](loc2: address)
	4: CopyLoc[5](loc2: address)
	5: CopyLoc[1](Arg1: Ty0)
	6: Call hash_type_and_key<Ty0>(address, Ty0): address
	7: StLoc[4](loc1: address)
	8: CopyLoc[5](loc2: address)
	9: CopyLoc[4](loc1: address)
	10: Call has_child_object(address, address): bool
	11: Not
	12: BrFalse(14)
B1:
	13: Branch(16)
B2:
	14: LdConst[0](u64: 0)
	15: Abort
B3:
	16: MoveLoc[4](loc1: address)
	17: Call object::new_uid_from_hash(address): UID
	18: MoveLoc[1](Arg1: Ty0)
	19: MoveLoc[2](Arg2: Ty1)
	20: PackGeneric[0](Field<Ty0, Ty1>)
	21: StLoc[3](loc0: Field<Ty0, Ty1>)
	22: MoveLoc[5](loc2: address)
	23: MoveLoc[3](loc0: Field<Ty0, Ty1>)
	24: Call add_child_object<Field<Ty0, Ty1>>(address, Field<Ty0, Ty1>)
	25: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store>(Arg0: &UID, Arg1: Ty0): &Ty1 {
L2:	loc0: address
B0:
	0: CopyLoc[0](Arg0: &UID)
	1: Call object::uid_to_address(&UID): address
	2: MoveLoc[1](Arg1: Ty0)
	3: Call hash_type_and_key<Ty0>(address, Ty0): address
	4: StLoc[2](loc0: address)
	5: MoveLoc[0](Arg0: &UID)
	6: MoveLoc[2](loc0: address)
	7: Call borrow_child_object<Field<Ty0, Ty1>>(&UID, address): &Field<Ty0, Ty1>
	8: ImmBorrowFieldGeneric[0](Field.value: Ty1)
	9: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): &mut Ty1 {
L2:	loc0: address
B0:
	0: CopyLoc[0](Arg0: &mut UID)
	1: FreezeRef
	2: Call object::uid_to_address(&UID): address
	3: MoveLoc[1](Arg1: Ty0)
	4: Call hash_type_and_key<Ty0>(address, Ty0): address
	5: StLoc[2](loc0: address)
	6: MoveLoc[0](Arg0: &mut UID)
	7: MoveLoc[2](loc0: address)
	8: Call borrow_child_object_mut<Field<Ty0, Ty1>>(&mut UID, address): &mut Field<Ty0, Ty1>
	9: MutBorrowFieldGeneric[0](Field.value: Ty1)
	10: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): Ty1 {
L2:	loc0: address
L3:	loc1: address
L4:	loc2: Ty1
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: FreezeRef
	2: Call object::uid_to_address(&UID): address
	3: StLoc[3](loc1: address)
	4: CopyLoc[3](loc1: address)
	5: MoveLoc[1](Arg1: Ty0)
	6: Call hash_type_and_key<Ty0>(address, Ty0): address
	7: StLoc[2](loc0: address)
	8: MoveLoc[3](loc1: address)
	9: MoveLoc[2](loc0: address)
	10: Call remove_child_object<Field<Ty0, Ty1>>(address, address): Field<Ty0, Ty1>
	11: UnpackGeneric[0](Field<Ty0, Ty1>)
	12: StLoc[4](loc2: Ty1)
	13: Pop
	14: Call object::delete(UID)
	15: MoveLoc[4](loc2: Ty1)
	16: Ret
}

public exists_<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): bool {
L2:	loc0: address
L3:	loc1: address
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: Call object::uid_to_address(&UID): address
	2: StLoc[3](loc1: address)
	3: CopyLoc[3](loc1: address)
	4: MoveLoc[1](Arg1: Ty0)
	5: Call hash_type_and_key<Ty0>(address, Ty0): address
	6: StLoc[2](loc0: address)
	7: MoveLoc[3](loc1: address)
	8: MoveLoc[2](loc0: address)
	9: Call has_child_object(address, address): bool
	10: Ret
}

public remove_if_exists<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): Option<Ty1> {
L2:	loc0: Option<Ty1>
B0:
	0: CopyLoc[0](Arg0: &mut UID)
	1: FreezeRef
	2: CopyLoc[1](Arg1: Ty0)
	3: Call exists_<Ty0>(&UID, Ty0): bool
	4: BrFalse(11)
B1:
	5: MoveLoc[0](Arg0: &mut UID)
	6: MoveLoc[1](Arg1: Ty0)
	7: Call remove<Ty0, Ty1>(&mut UID, Ty0): Ty1
	8: Call option::some<Ty1>(Ty1): Option<Ty1>
	9: StLoc[2](loc0: Option<Ty1>)
	10: Branch(15)
B2:
	11: MoveLoc[0](Arg0: &mut UID)
	12: Pop
	13: Call option::none<Ty1>(): Option<Ty1>
	14: StLoc[2](loc0: Option<Ty1>)
B3:
	15: MoveLoc[2](loc0: Option<Ty1>)
	16: Ret
}

public exists_with_type<Ty0: copy + drop + store, Ty1: store>(Arg0: &UID, Arg1: Ty0): bool {
L2:	loc0: address
L3:	loc1: address
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: Call object::uid_to_address(&UID): address
	2: StLoc[3](loc1: address)
	3: CopyLoc[3](loc1: address)
	4: MoveLoc[1](Arg1: Ty0)
	5: Call hash_type_and_key<Ty0>(address, Ty0): address
	6: StLoc[2](loc0: address)
	7: MoveLoc[3](loc1: address)
	8: MoveLoc[2](loc0: address)
	9: Call has_child_object_with_ty<Field<Ty0, Ty1>>(address, address): bool
	10: Ret
}

public(friend) field_info<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): &UID * address {
L2:	loc0: &Field<Ty0, ID>
L3:	loc1: address
L4:	loc2: &UID
L5:	loc3: &ID
B0:
	0: CopyLoc[0](Arg0: &UID)
	1: Call object::uid_to_address(&UID): address
	2: MoveLoc[1](Arg1: Ty0)
	3: Call hash_type_and_key<Ty0>(address, Ty0): address
	4: StLoc[3](loc1: address)
	5: MoveLoc[0](Arg0: &UID)
	6: MoveLoc[3](loc1: address)
	7: Call borrow_child_object<Field<Ty0, ID>>(&UID, address): &Field<Ty0, ID>
	8: StLoc[2](loc0: &Field<Ty0, ID>)
	9: CopyLoc[2](loc0: &Field<Ty0, ID>)
	10: ImmBorrowFieldGeneric[1](Field.id: UID)
	11: StLoc[4](loc2: &UID)
	12: CopyLoc[2](loc0: &Field<Ty0, ID>)
	13: ImmBorrowFieldGeneric[2](Field.name: Ty0)
	14: Pop
	15: MoveLoc[2](loc0: &Field<Ty0, ID>)
	16: ImmBorrowFieldGeneric[3](Field.value: ID)
	17: StLoc[5](loc3: &ID)
	18: MoveLoc[4](loc2: &UID)
	19: MoveLoc[5](loc3: &ID)
	20: Call object::id_to_address(&ID): address
	21: Ret
}

public(friend) field_info_mut<Ty0: copy + drop + store>(Arg0: &mut UID, Arg1: Ty0): &mut UID * address {
L2:	loc0: &mut Field<Ty0, ID>
L3:	loc1: address
L4:	loc2: &mut UID
L5:	loc3: &mut ID
B0:
	0: CopyLoc[0](Arg0: &mut UID)
	1: FreezeRef
	2: Call object::uid_to_address(&UID): address
	3: MoveLoc[1](Arg1: Ty0)
	4: Call hash_type_and_key<Ty0>(address, Ty0): address
	5: StLoc[3](loc1: address)
	6: MoveLoc[0](Arg0: &mut UID)
	7: MoveLoc[3](loc1: address)
	8: Call borrow_child_object_mut<Field<Ty0, ID>>(&mut UID, address): &mut Field<Ty0, ID>
	9: StLoc[2](loc0: &mut Field<Ty0, ID>)
	10: CopyLoc[2](loc0: &mut Field<Ty0, ID>)
	11: MutBorrowFieldGeneric[1](Field.id: UID)
	12: StLoc[4](loc2: &mut UID)
	13: CopyLoc[2](loc0: &mut Field<Ty0, ID>)
	14: MutBorrowFieldGeneric[2](Field.name: Ty0)
	15: Pop
	16: MoveLoc[2](loc0: &mut Field<Ty0, ID>)
	17: MutBorrowFieldGeneric[3](Field.value: ID)
	18: StLoc[5](loc3: &mut ID)
	19: MoveLoc[4](loc2: &mut UID)
	20: MoveLoc[5](loc3: &mut ID)
	21: FreezeRef
	22: Call object::id_to_address(&ID): address
	23: Ret
}

native public(friend) hash_type_and_key<Ty0: copy + drop + store>(Arg0: address, Arg1: Ty0): address;

native public(friend) add_child_object<Ty0: key>(Arg0: address, Arg1: Ty0);

native public(friend) borrow_child_object<Ty0: key>(Arg0: &UID, Arg1: address): &Ty0;

native public(friend) borrow_child_object_mut<Ty0: key>(Arg0: &mut UID, Arg1: address): &mut Ty0;

native public(friend) remove_child_object<Ty0: key>(Arg0: address, Arg1: address): Ty0;

native public(friend) has_child_object(Arg0: address, Arg1: address): bool;

native public(friend) has_child_object_with_ty<Ty0: key>(Arg0: address, Arg1: address): bool;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
]
}

// Move bytecode v6
module 2.dynamic_object_field {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct Wrapper<Ty0> has copy, drop, store {
	name: Ty0
}

public add<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut UID, Arg1: Ty0, Arg2: Ty1) {
L3:	loc0: ID
L4:	loc1: Wrapper<Ty0>
L5:	loc2: Ty0
L6:	loc3: &mut UID
L7:	loc4: Ty1
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: StLoc[6](loc3: &mut UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: StLoc[5](loc2: Ty0)
	4: MoveLoc[2](Arg2: Ty1)
	5: StLoc[7](loc4: Ty1)
	6: MoveLoc[5](loc2: Ty0)
	7: PackGeneric[0](Wrapper<Ty0>)
	8: StLoc[4](loc1: Wrapper<Ty0>)
	9: ImmBorrowLoc[7](loc4: Ty1)
	10: Call object::id<Ty1>(&Ty1): ID
	11: StLoc[3](loc0: ID)
	12: CopyLoc[6](loc3: &mut UID)
	13: CopyLoc[4](loc1: Wrapper<Ty0>)
	14: MoveLoc[3](loc0: ID)
	15: Call dynamic_field::add<Wrapper<Ty0>, ID>(&mut UID, Wrapper<Ty0>, ID)
	16: MoveLoc[6](loc3: &mut UID)
	17: FreezeRef
	18: MoveLoc[4](loc1: Wrapper<Ty0>)
	19: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	20: Pop
	21: Call object::uid_to_address(&UID): address
	22: MoveLoc[7](loc4: Ty1)
	23: Call dynamic_field::add_child_object<Ty1>(address, Ty1)
	24: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &UID, Arg1: Ty0): &Ty1 {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: &UID
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: StLoc[3](loc1: &UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[2](loc0: Wrapper<Ty0>)
	5: MoveLoc[3](loc1: &UID)
	6: MoveLoc[2](loc0: Wrapper<Ty0>)
	7: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	8: Call dynamic_field::borrow_child_object<Ty1>(&UID, address): &Ty1
	9: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut UID, Arg1: Ty0): &mut Ty1 {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: &mut UID
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: StLoc[3](loc1: &mut UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[2](loc0: Wrapper<Ty0>)
	5: MoveLoc[3](loc1: &mut UID)
	6: MoveLoc[2](loc0: Wrapper<Ty0>)
	7: Call dynamic_field::field_info_mut<Wrapper<Ty0>>(&mut UID, Wrapper<Ty0>): &mut UID * address
	8: Call dynamic_field::borrow_child_object_mut<Ty1>(&mut UID, address): &mut Ty1
	9: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut UID, Arg1: Ty0): Ty1 {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: &mut UID
L4:	loc2: Ty1
L5:	loc3: address
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: StLoc[3](loc1: &mut UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[2](loc0: Wrapper<Ty0>)
	5: CopyLoc[3](loc1: &mut UID)
	6: FreezeRef
	7: CopyLoc[2](loc0: Wrapper<Ty0>)
	8: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	9: StLoc[5](loc3: address)
	10: Call object::uid_to_address(&UID): address
	11: MoveLoc[5](loc3: address)
	12: Call dynamic_field::remove_child_object<Ty1>(address, address): Ty1
	13: StLoc[4](loc2: Ty1)
	14: MoveLoc[3](loc1: &mut UID)
	15: MoveLoc[2](loc0: Wrapper<Ty0>)
	16: Call dynamic_field::remove<Wrapper<Ty0>, ID>(&mut UID, Wrapper<Ty0>): ID
	17: Pop
	18: MoveLoc[4](loc2: Ty1)
	19: Ret
}

public exists_<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): bool {
L2:	loc0: Wrapper<Ty0>
B0:
	0: MoveLoc[1](Arg1: Ty0)
	1: PackGeneric[0](Wrapper<Ty0>)
	2: StLoc[2](loc0: Wrapper<Ty0>)
	3: MoveLoc[0](Arg0: &UID)
	4: MoveLoc[2](loc0: Wrapper<Ty0>)
	5: Call dynamic_field::exists_with_type<Wrapper<Ty0>, ID>(&UID, Wrapper<Ty0>): bool
	6: Ret
}

public exists_with_type<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &UID, Arg1: Ty0): bool {
L2:	loc0: bool
L3:	loc1: Wrapper<Ty0>
L4:	loc2: &UID
L5:	loc3: address
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: StLoc[4](loc2: &UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[3](loc1: Wrapper<Ty0>)
	5: CopyLoc[4](loc2: &UID)
	6: CopyLoc[3](loc1: Wrapper<Ty0>)
	7: Call dynamic_field::exists_with_type<Wrapper<Ty0>, ID>(&UID, Wrapper<Ty0>): bool
	8: Not
	9: BrFalse(15)
B1:
	10: MoveLoc[4](loc2: &UID)
	11: Pop
	12: LdFalse
	13: StLoc[2](loc0: bool)
	14: Branch(23)
B2:
	15: MoveLoc[4](loc2: &UID)
	16: MoveLoc[3](loc1: Wrapper<Ty0>)
	17: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	18: StLoc[5](loc3: address)
	19: Call object::uid_to_address(&UID): address
	20: MoveLoc[5](loc3: address)
	21: Call dynamic_field::has_child_object_with_ty<Ty1>(address, address): bool
	22: StLoc[2](loc0: bool)
B3:
	23: MoveLoc[2](loc0: bool)
	24: Ret
}

public id<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): Option<ID> {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: address
B0:
	0: MoveLoc[1](Arg1: Ty0)
	1: PackGeneric[0](Wrapper<Ty0>)
	2: StLoc[2](loc0: Wrapper<Ty0>)
	3: CopyLoc[0](Arg0: &UID)
	4: CopyLoc[2](loc0: Wrapper<Ty0>)
	5: Call dynamic_field::exists_with_type<Wrapper<Ty0>, ID>(&UID, Wrapper<Ty0>): bool
	6: Not
	7: BrFalse(12)
B1:
	8: MoveLoc[0](Arg0: &UID)
	9: Pop
	10: Call option::none<ID>(): Option<ID>
	11: Ret
B2:
	12: MoveLoc[0](Arg0: &UID)
	13: MoveLoc[2](loc0: Wrapper<Ty0>)
	14: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	15: StLoc[3](loc1: address)
	16: Pop
	17: MoveLoc[3](loc1: address)
	18: Call object::id_from_address(address): ID
	19: Call option::some<ID>(ID): Option<ID>
	20: Ret
}

public(friend) internal_add<Ty0: copy + drop + store, Ty1: key>(Arg0: &mut UID, Arg1: Ty0, Arg2: Ty1) {
L3:	loc0: ID
L4:	loc1: Wrapper<Ty0>
L5:	loc2: Ty0
L6:	loc3: &mut UID
L7:	loc4: Ty1
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: StLoc[6](loc3: &mut UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: StLoc[5](loc2: Ty0)
	4: MoveLoc[2](Arg2: Ty1)
	5: StLoc[7](loc4: Ty1)
	6: MoveLoc[5](loc2: Ty0)
	7: PackGeneric[0](Wrapper<Ty0>)
	8: StLoc[4](loc1: Wrapper<Ty0>)
	9: ImmBorrowLoc[7](loc4: Ty1)
	10: Call object::id<Ty1>(&Ty1): ID
	11: StLoc[3](loc0: ID)
	12: CopyLoc[6](loc3: &mut UID)
	13: CopyLoc[4](loc1: Wrapper<Ty0>)
	14: MoveLoc[3](loc0: ID)
	15: Call dynamic_field::add<Wrapper<Ty0>, ID>(&mut UID, Wrapper<Ty0>, ID)
	16: MoveLoc[6](loc3: &mut UID)
	17: FreezeRef
	18: MoveLoc[4](loc1: Wrapper<Ty0>)
	19: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	20: Pop
	21: Call object::uid_to_address(&UID): address
	22: MoveLoc[7](loc4: Ty1)
	23: Call dynamic_field::add_child_object<Ty1>(address, Ty1)
	24: Ret
}

public(friend) internal_borrow<Ty0: copy + drop + store, Ty1: key>(Arg0: &UID, Arg1: Ty0): &Ty1 {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: &UID
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: StLoc[3](loc1: &UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[2](loc0: Wrapper<Ty0>)
	5: MoveLoc[3](loc1: &UID)
	6: MoveLoc[2](loc0: Wrapper<Ty0>)
	7: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	8: Call dynamic_field::borrow_child_object<Ty1>(&UID, address): &Ty1
	9: Ret
}

public(friend) internal_borrow_mut<Ty0: copy + drop + store, Ty1: key>(Arg0: &mut UID, Arg1: Ty0): &mut Ty1 {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: &mut UID
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: StLoc[3](loc1: &mut UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[2](loc0: Wrapper<Ty0>)
	5: MoveLoc[3](loc1: &mut UID)
	6: MoveLoc[2](loc0: Wrapper<Ty0>)
	7: Call dynamic_field::field_info_mut<Wrapper<Ty0>>(&mut UID, Wrapper<Ty0>): &mut UID * address
	8: Call dynamic_field::borrow_child_object_mut<Ty1>(&mut UID, address): &mut Ty1
	9: Ret
}

public(friend) internal_remove<Ty0: copy + drop + store, Ty1: key>(Arg0: &mut UID, Arg1: Ty0): Ty1 {
L2:	loc0: Wrapper<Ty0>
L3:	loc1: &mut UID
L4:	loc2: Ty1
L5:	loc3: address
B0:
	0: MoveLoc[0](Arg0: &mut UID)
	1: StLoc[3](loc1: &mut UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[2](loc0: Wrapper<Ty0>)
	5: CopyLoc[3](loc1: &mut UID)
	6: FreezeRef
	7: CopyLoc[2](loc0: Wrapper<Ty0>)
	8: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	9: StLoc[5](loc3: address)
	10: Call object::uid_to_address(&UID): address
	11: MoveLoc[5](loc3: address)
	12: Call dynamic_field::remove_child_object<Ty1>(address, address): Ty1
	13: StLoc[4](loc2: Ty1)
	14: MoveLoc[3](loc1: &mut UID)
	15: MoveLoc[2](loc0: Wrapper<Ty0>)
	16: Call dynamic_field::remove<Wrapper<Ty0>, ID>(&mut UID, Wrapper<Ty0>): ID
	17: Pop
	18: MoveLoc[4](loc2: Ty1)
	19: Ret
}

public(friend) internal_exists_with_type<Ty0: copy + drop + store, Ty1: key>(Arg0: &UID, Arg1: Ty0): bool {
L2:	loc0: bool
L3:	loc1: Wrapper<Ty0>
L4:	loc2: &UID
L5:	loc3: address
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: StLoc[4](loc2: &UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: PackGeneric[0](Wrapper<Ty0>)
	4: StLoc[3](loc1: Wrapper<Ty0>)
	5: CopyLoc[4](loc2: &UID)
	6: CopyLoc[3](loc1: Wrapper<Ty0>)
	7: Call dynamic_field::exists_with_type<Wrapper<Ty0>, ID>(&UID, Wrapper<Ty0>): bool
	8: Not
	9: BrFalse(15)
B1:
	10: MoveLoc[4](loc2: &UID)
	11: Pop
	12: LdFalse
	13: StLoc[2](loc0: bool)
	14: Branch(23)
B2:
	15: MoveLoc[4](loc2: &UID)
	16: MoveLoc[3](loc1: Wrapper<Ty0>)
	17: Call dynamic_field::field_info<Wrapper<Ty0>>(&UID, Wrapper<Ty0>): &UID * address
	18: StLoc[5](loc3: address)
	19: Call object::uid_to_address(&UID): address
	20: MoveLoc[5](loc3: address)
	21: Call dynamic_field::has_child_object_with_ty<Ty1>(address, address): bool
	22: StLoc[2](loc0: bool)
B3:
	23: MoveLoc[2](loc0: bool)
	24: Ret
}

}

// Move bytecode v6
module 2.ecdsa_k1 {

native public secp256k1_ecrecover(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: u8): vector<u8>;

native public decompress_pubkey(Arg0: &vector<u8>): vector<u8>;

native public secp256k1_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: u8): bool;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u8: 0
	4 => u8: 1
]
}

// Move bytecode v6
module 2.ecdsa_r1 {

native public secp256r1_ecrecover(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: u8): vector<u8>;

native public secp256r1_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: u8): bool;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u8: 0
	3 => u8: 1
]
}

// Move bytecode v6
module 2.ecvrf {

native public ecvrf_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: &vector<u8>): bool;

Constants [
	0 => u64: 1
	1 => u64: 2
	2 => u64: 3
]
}

// Move bytecode v6
module 2.ed25519 {

native public ed25519_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>): bool;

}

// Move bytecode v6
module 2.event {

native public emit<Ty0: copy + drop>(Arg0: Ty0);

}

// Move bytecode v6
module 2.groth16 {

struct Curve has copy, drop, store {
	id: u8
}

struct PreparedVerifyingKey has copy, drop, store {
	vk_gamma_abc_g1_bytes: vector<u8>,
	alpha_g1_beta_g2_bytes: vector<u8>,
	gamma_g2_neg_pc_bytes: vector<u8>,
	delta_g2_neg_pc_bytes: vector<u8>
}

struct PublicProofInputs has copy, drop, store {
	bytes: vector<u8>
}

struct ProofPoints has copy, drop, store {
	bytes: vector<u8>
}

public bls12381(): Curve {
B0:
	0: LdU8(0)
	1: Pack[0](Curve)
	2: Ret
}

public bn254(): Curve {
B0:
	0: LdU8(1)
	1: Pack[0](Curve)
	2: Ret
}

public pvk_from_bytes(Arg0: vector<u8>, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: vector<u8>): PreparedVerifyingKey {
B0:
	0: MoveLoc[0](Arg0: vector<u8>)
	1: MoveLoc[1](Arg1: vector<u8>)
	2: MoveLoc[2](Arg2: vector<u8>)
	3: MoveLoc[3](Arg3: vector<u8>)
	4: Pack[1](PreparedVerifyingKey)
	5: Ret
}

public pvk_to_bytes(Arg0: PreparedVerifyingKey): vector<vector<u8>> {
B0:
	0: ImmBorrowLoc[0](Arg0: PreparedVerifyingKey)
	1: ImmBorrowField[0](PreparedVerifyingKey.vk_gamma_abc_g1_bytes: vector<u8>)
	2: ReadRef
	3: ImmBorrowLoc[0](Arg0: PreparedVerifyingKey)
	4: ImmBorrowField[1](PreparedVerifyingKey.alpha_g1_beta_g2_bytes: vector<u8>)
	5: ReadRef
	6: ImmBorrowLoc[0](Arg0: PreparedVerifyingKey)
	7: ImmBorrowField[2](PreparedVerifyingKey.gamma_g2_neg_pc_bytes: vector<u8>)
	8: ReadRef
	9: ImmBorrowLoc[0](Arg0: PreparedVerifyingKey)
	10: ImmBorrowField[3](PreparedVerifyingKey.delta_g2_neg_pc_bytes: vector<u8>)
	11: ReadRef
	12: VecPack(5, 4)
	13: Ret
}

public public_proof_inputs_from_bytes(Arg0: vector<u8>): PublicProofInputs {
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u8>)
	1: VecLen(13)
	2: LdU64(32)
	3: Mod
	4: LdU64(0)
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdConst[3](u64: 3)
	9: Abort
B3:
	10: ImmBorrowLoc[0](Arg0: vector<u8>)
	11: VecLen(13)
	12: LdU64(32)
	13: Div
	14: LdConst[4](u64: 8)
	15: Le
	16: BrFalse(18)
B4:
	17: Branch(20)
B5:
	18: LdConst[2](u64: 2)
	19: Abort
B6:
	20: MoveLoc[0](Arg0: vector<u8>)
	21: Pack[2](PublicProofInputs)
	22: Ret
}

public proof_points_from_bytes(Arg0: vector<u8>): ProofPoints {
B0:
	0: MoveLoc[0](Arg0: vector<u8>)
	1: Pack[3](ProofPoints)
	2: Ret
}

public prepare_verifying_key(Arg0: &Curve, Arg1: &vector<u8>): PreparedVerifyingKey {
B0:
	0: MoveLoc[0](Arg0: &Curve)
	1: ImmBorrowField[4](Curve.id: u8)
	2: ReadRef
	3: MoveLoc[1](Arg1: &vector<u8>)
	4: Call prepare_verifying_key_internal(u8, &vector<u8>): PreparedVerifyingKey
	5: Ret
}

native prepare_verifying_key_internal(Arg0: u8, Arg1: &vector<u8>): PreparedVerifyingKey;

public verify_groth16_proof(Arg0: &Curve, Arg1: &PreparedVerifyingKey, Arg2: &PublicProofInputs, Arg3: &ProofPoints): bool {
B0:
	0: MoveLoc[0](Arg0: &Curve)
	1: ImmBorrowField[4](Curve.id: u8)
	2: ReadRef
	3: CopyLoc[1](Arg1: &PreparedVerifyingKey)
	4: ImmBorrowField[0](PreparedVerifyingKey.vk_gamma_abc_g1_bytes: vector<u8>)
	5: CopyLoc[1](Arg1: &PreparedVerifyingKey)
	6: ImmBorrowField[1](PreparedVerifyingKey.alpha_g1_beta_g2_bytes: vector<u8>)
	7: CopyLoc[1](Arg1: &PreparedVerifyingKey)
	8: ImmBorrowField[2](PreparedVerifyingKey.gamma_g2_neg_pc_bytes: vector<u8>)
	9: MoveLoc[1](Arg1: &PreparedVerifyingKey)
	10: ImmBorrowField[3](PreparedVerifyingKey.delta_g2_neg_pc_bytes: vector<u8>)
	11: MoveLoc[2](Arg2: &PublicProofInputs)
	12: ImmBorrowField[5](PublicProofInputs.bytes: vector<u8>)
	13: MoveLoc[3](Arg3: &ProofPoints)
	14: ImmBorrowField[6](ProofPoints.bytes: vector<u8>)
	15: Call verify_groth16_proof_internal(u8, &vector<u8>, &vector<u8>, &vector<u8>, &vector<u8>, &vector<u8>, &vector<u8>): bool
	16: Ret
}

native verify_groth16_proof_internal(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: &vector<u8>, Arg4: &vector<u8>, Arg5: &vector<u8>, Arg6: &vector<u8>): bool;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 8
]
}

// Move bytecode v6
module 2.group_ops {
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct Element<phantom Ty0> has copy, drop, store {
	bytes: vector<u8>
}

public bytes<Ty0>(Arg0: &Element<Ty0>): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Element<Ty0>)
	1: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	2: Ret
}

public equal<Ty0>(Arg0: &Element<Ty0>, Arg1: &Element<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &Element<Ty0>)
	1: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	2: MoveLoc[1](Arg1: &Element<Ty0>)
	3: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	4: Eq
	5: Ret
}

public(friend) from_bytes<Ty0>(Arg0: u8, Arg1: &vector<u8>, Arg2: bool): Element<Ty0> {
L3:	loc0: bool
B0:
	0: MoveLoc[2](Arg2: bool)
	1: BrFalse(5)
B1:
	2: LdTrue
	3: StLoc[3](loc0: bool)
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: u8)
	6: CopyLoc[1](Arg1: &vector<u8>)
	7: Call internal_validate(u8, &vector<u8>): bool
	8: StLoc[3](loc0: bool)
B3:
	9: MoveLoc[3](loc0: bool)
	10: BrFalse(12)
B4:
	11: Branch(16)
B5:
	12: MoveLoc[1](Arg1: &vector<u8>)
	13: Pop
	14: LdConst[1](u64: 1)
	15: Abort
B6:
	16: MoveLoc[1](Arg1: &vector<u8>)
	17: ReadRef
	18: PackGeneric[0](Element<Ty0>)
	19: Ret
}

public(friend) add<Ty0>(Arg0: u8, Arg1: &Element<Ty0>, Arg2: &Element<Ty0>): Element<Ty0> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: &Element<Ty0>)
	2: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	3: MoveLoc[2](Arg2: &Element<Ty0>)
	4: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	5: Call internal_add(u8, &vector<u8>, &vector<u8>): vector<u8>
	6: PackGeneric[0](Element<Ty0>)
	7: Ret
}

public(friend) sub<Ty0>(Arg0: u8, Arg1: &Element<Ty0>, Arg2: &Element<Ty0>): Element<Ty0> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: &Element<Ty0>)
	2: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	3: MoveLoc[2](Arg2: &Element<Ty0>)
	4: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	5: Call internal_sub(u8, &vector<u8>, &vector<u8>): vector<u8>
	6: PackGeneric[0](Element<Ty0>)
	7: Ret
}

public(friend) mul<Ty0, Ty1>(Arg0: u8, Arg1: &Element<Ty0>, Arg2: &Element<Ty1>): Element<Ty1> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: &Element<Ty0>)
	2: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	3: MoveLoc[2](Arg2: &Element<Ty1>)
	4: ImmBorrowFieldGeneric[1](Element.bytes: vector<u8>)
	5: Call internal_mul(u8, &vector<u8>, &vector<u8>): vector<u8>
	6: PackGeneric[1](Element<Ty1>)
	7: Ret
}

public(friend) div<Ty0, Ty1>(Arg0: u8, Arg1: &Element<Ty0>, Arg2: &Element<Ty1>): Element<Ty1> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: &Element<Ty0>)
	2: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	3: MoveLoc[2](Arg2: &Element<Ty1>)
	4: ImmBorrowFieldGeneric[1](Element.bytes: vector<u8>)
	5: Call internal_div(u8, &vector<u8>, &vector<u8>): vector<u8>
	6: PackGeneric[1](Element<Ty1>)
	7: Ret
}

public(friend) hash_to<Ty0>(Arg0: u8, Arg1: &vector<u8>): Element<Ty0> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: &vector<u8>)
	2: Call internal_hash_to(u8, &vector<u8>): vector<u8>
	3: PackGeneric[0](Element<Ty0>)
	4: Ret
}

public(friend) multi_scalar_multiplication<Ty0, Ty1>(Arg0: u8, Arg1: &vector<Element<Ty0>>, Arg2: &vector<Element<Ty1>>): Element<Ty1> {
L3:	loc0: Element<Ty1>
L4:	loc1: vector<u8>
L5:	loc2: u64
L6:	loc3: Element<Ty0>
L7:	loc4: vector<u8>
B0:
	0: CopyLoc[1](Arg1: &vector<Element<Ty0>>)
	1: VecLen(5)
	2: LdU64(0)
	3: Gt
	4: BrFalse(6)
B1:
	5: Branch(12)
B2:
	6: MoveLoc[1](Arg1: &vector<Element<Ty0>>)
	7: Pop
	8: MoveLoc[2](Arg2: &vector<Element<Ty1>>)
	9: Pop
	10: LdConst[1](u64: 1)
	11: Abort
B3:
	12: CopyLoc[1](Arg1: &vector<Element<Ty0>>)
	13: VecLen(5)
	14: CopyLoc[2](Arg2: &vector<Element<Ty1>>)
	15: VecLen(8)
	16: Eq
	17: BrFalse(19)
B4:
	18: Branch(25)
B5:
	19: MoveLoc[1](Arg1: &vector<Element<Ty0>>)
	20: Pop
	21: MoveLoc[2](Arg2: &vector<Element<Ty1>>)
	22: Pop
	23: LdConst[1](u64: 1)
	24: Abort
B6:
	25: LdConst[4](vector<u8>: "" /..)
	26: StLoc[7](loc4: vector<u8>)
	27: LdConst[4](vector<u8>: "" /..)
	28: StLoc[4](loc1: vector<u8>)
	29: LdU64(0)
	30: StLoc[5](loc2: u64)
B7:
	31: CopyLoc[5](loc2: u64)
	32: CopyLoc[1](Arg1: &vector<Element<Ty0>>)
	33: VecLen(5)
	34: Lt
	35: BrFalse(61)
B8:
	36: CopyLoc[1](Arg1: &vector<Element<Ty0>>)
	37: CopyLoc[5](loc2: u64)
	38: VecImmBorrow(5)
	39: ReadRef
	40: StLoc[6](loc3: Element<Ty0>)
	41: MutBorrowLoc[7](loc4: vector<u8>)
	42: ImmBorrowLoc[6](loc3: Element<Ty0>)
	43: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	44: ReadRef
	45: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	46: CopyLoc[2](Arg2: &vector<Element<Ty1>>)
	47: CopyLoc[5](loc2: u64)
	48: VecImmBorrow(8)
	49: ReadRef
	50: StLoc[3](loc0: Element<Ty1>)
	51: MutBorrowLoc[4](loc1: vector<u8>)
	52: ImmBorrowLoc[3](loc0: Element<Ty1>)
	53: ImmBorrowFieldGeneric[1](Element.bytes: vector<u8>)
	54: ReadRef
	55: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	56: MoveLoc[5](loc2: u64)
	57: LdU64(1)
	58: Add
	59: StLoc[5](loc2: u64)
	60: Branch(31)
B9:
	61: MoveLoc[1](Arg1: &vector<Element<Ty0>>)
	62: Pop
	63: MoveLoc[2](Arg2: &vector<Element<Ty1>>)
	64: Pop
	65: MoveLoc[0](Arg0: u8)
	66: ImmBorrowLoc[7](loc4: vector<u8>)
	67: ImmBorrowLoc[4](loc1: vector<u8>)
	68: Call internal_multi_scalar_mul(u8, &vector<u8>, &vector<u8>): vector<u8>
	69: PackGeneric[1](Element<Ty1>)
	70: Ret
}

public(friend) pairing<Ty0, Ty1, Ty2>(Arg0: u8, Arg1: &Element<Ty0>, Arg2: &Element<Ty1>): Element<Ty2> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: &Element<Ty0>)
	2: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	3: MoveLoc[2](Arg2: &Element<Ty1>)
	4: ImmBorrowFieldGeneric[1](Element.bytes: vector<u8>)
	5: Call internal_pairing(u8, &vector<u8>, &vector<u8>): vector<u8>
	6: PackGeneric[2](Element<Ty2>)
	7: Ret
}

public(friend) convert<Ty0, Ty1>(Arg0: u8, Arg1: u8, Arg2: &Element<Ty0>): Element<Ty1> {
B0:
	0: MoveLoc[0](Arg0: u8)
	1: MoveLoc[1](Arg1: u8)
	2: MoveLoc[2](Arg2: &Element<Ty0>)
	3: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	4: Call internal_convert(u8, u8, &vector<u8>): vector<u8>
	5: PackGeneric[1](Element<Ty1>)
	6: Ret
}

public(friend) sum<Ty0>(Arg0: u8, Arg1: &vector<Element<Ty0>>): Element<Ty0> {
L2:	loc0: u64
L3:	loc1: vector<u8>
L4:	loc2: &mut vector<vector<u8>>
L5:	loc3: vector<vector<u8>>
L6:	loc4: u8
L7:	loc5: Element<Ty0>
L8:	loc6: u64
L9:	loc7: vector<vector<u8>>
L10:	loc8: u64
L11:	loc9: vector<Element<Ty0>>
L12:	loc10: vector<Element<Ty0>>
L13:	loc11: Element<Ty0>
B0:
	0: MoveLoc[0](Arg0: u8)
	1: StLoc[6](loc4: u8)
	2: MoveLoc[1](Arg1: &vector<Element<Ty0>>)
	3: ReadRef
	4: StLoc[11](loc9: vector<Element<Ty0>>)
	5: LdConst[5](vector<vector<u8>>: 00)
	6: StLoc[9](loc7: vector<vector<u8>>)
	7: MoveLoc[11](loc9: vector<Element<Ty0>>)
	8: StLoc[12](loc10: vector<Element<Ty0>>)
	9: MutBorrowLoc[12](loc10: vector<Element<Ty0>>)
	10: Call vector::reverse<Element<Ty0>>(&mut vector<Element<Ty0>>)
	11: ImmBorrowLoc[12](loc10: vector<Element<Ty0>>)
	12: VecLen(5)
	13: StLoc[2](loc0: u64)
	14: LdU64(0)
	15: StLoc[8](loc6: u64)
	16: MoveLoc[2](loc0: u64)
	17: StLoc[10](loc8: u64)
B1:
	18: CopyLoc[8](loc6: u64)
	19: CopyLoc[10](loc8: u64)
	20: Lt
	21: BrFalse(43)
B2:
	22: CopyLoc[8](loc6: u64)
	23: Pop
	24: MutBorrowLoc[12](loc10: vector<Element<Ty0>>)
	25: VecPopBack(5)
	26: StLoc[7](loc5: Element<Ty0>)
	27: MutBorrowLoc[9](loc7: vector<vector<u8>>)
	28: StLoc[4](loc2: &mut vector<vector<u8>>)
	29: MoveLoc[7](loc5: Element<Ty0>)
	30: StLoc[13](loc11: Element<Ty0>)
	31: ImmBorrowLoc[13](loc11: Element<Ty0>)
	32: ImmBorrowFieldGeneric[0](Element.bytes: vector<u8>)
	33: ReadRef
	34: StLoc[3](loc1: vector<u8>)
	35: MoveLoc[4](loc2: &mut vector<vector<u8>>)
	36: MoveLoc[3](loc1: vector<u8>)
	37: VecPushBack(15)
	38: MoveLoc[8](loc6: u64)
	39: LdU64(1)
	40: Add
	41: StLoc[8](loc6: u64)
	42: Branch(18)
B3:
	43: MoveLoc[12](loc10: vector<Element<Ty0>>)
	44: VecUnpack(5, 0)
	45: MoveLoc[9](loc7: vector<vector<u8>>)
	46: StLoc[5](loc3: vector<vector<u8>>)
	47: MoveLoc[6](loc4: u8)
	48: ImmBorrowLoc[5](loc3: vector<vector<u8>>)
	49: Call internal_sum(u8, &vector<vector<u8>>): vector<u8>
	50: PackGeneric[0](Element<Ty0>)
	51: Ret
}

native internal_validate(Arg0: u8, Arg1: &vector<u8>): bool;

native internal_add(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>): vector<u8>;

native internal_sub(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>): vector<u8>;

native internal_mul(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>): vector<u8>;

native internal_div(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>): vector<u8>;

native internal_hash_to(Arg0: u8, Arg1: &vector<u8>): vector<u8>;

native internal_multi_scalar_mul(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>): vector<u8>;

native internal_pairing(Arg0: u8, Arg1: &vector<u8>, Arg2: &vector<u8>): vector<u8>;

native internal_convert(Arg0: u8, Arg1: u8, Arg2: &vector<u8>): vector<u8>;

native internal_sum(Arg0: u8, Arg1: &vector<vector<u8>>): vector<u8>;

public(friend) set_as_prefix(Arg0: u64, Arg1: bool, Arg2: &mut vector<u8>) {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: vector<u8>
B0:
	0: CopyLoc[2](Arg2: &mut vector<u8>)
	1: FreezeRef
	2: VecLen(23)
	3: StLoc[4](loc1: u64)
	4: CopyLoc[4](loc1: u64)
	5: LdU64(7)
	6: Gt
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[2](Arg2: &mut vector<u8>)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: ImmBorrowLoc[0](Arg0: u64)
	14: Call bcs::to_bytes<u64>(&u64): vector<u8>
	15: StLoc[7](loc4: vector<u8>)
	16: LdU64(0)
	17: StLoc[5](loc2: u64)
B4:
	18: CopyLoc[5](loc2: u64)
	19: LdU64(8)
	20: Lt
	21: BrFalse(49)
B5:
	22: CopyLoc[1](Arg1: bool)
	23: BrFalse(32)
B6:
	24: Branch(25)
B7:
	25: CopyLoc[4](loc1: u64)
	26: CopyLoc[5](loc2: u64)
	27: Sub
	28: LdU64(1)
	29: Sub
	30: StLoc[3](loc0: u64)
	31: Branch(34)
B8:
	32: CopyLoc[5](loc2: u64)
	33: StLoc[3](loc0: u64)
B9:
	34: MoveLoc[3](loc0: u64)
	35: StLoc[6](loc3: u64)
	36: ImmBorrowLoc[7](loc4: vector<u8>)
	37: CopyLoc[5](loc2: u64)
	38: VecImmBorrow(23)
	39: ReadRef
	40: CopyLoc[2](Arg2: &mut vector<u8>)
	41: MoveLoc[6](loc3: u64)
	42: VecMutBorrow(23)
	43: WriteRef
	44: MoveLoc[5](loc2: u64)
	45: LdU64(1)
	46: Add
	47: StLoc[5](loc2: u64)
	48: Branch(18)
B10:
	49: MoveLoc[2](Arg2: &mut vector<u8>)
	50: Pop
	51: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => vector<u8>: "" // interpreted as UTF8 string
	5 => vector<vector<u8>>: 00
]
}

// Move bytecode v6
module 2.hash {

native public blake2b256(Arg0: &vector<u8>): vector<u8>;

native public keccak256(Arg0: &vector<u8>): vector<u8>;

}

// Move bytecode v6
module 2.hex {
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

public encode(Arg0: vector<u8>): vector<u8> {
L1:	loc0: vector<vector<u8>>
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: vector<u8>
B0:
	0: LdU64(0)
	1: LdConst[3](vector<u8>: "" /..)
	2: ImmBorrowLoc[0](Arg0: vector<u8>)
	3: VecLen(1)
	4: StLoc[3](loc2: u64)
	5: StLoc[4](loc3: vector<u8>)
	6: StLoc[2](loc1: u64)
	7: LdConst[2](vector<vector<u8>>: 8002..)
	8: StLoc[1](loc0: vector<vector<u8>>)
B1:
	9: CopyLoc[2](loc1: u64)
	10: CopyLoc[3](loc2: u64)
	11: Lt
	12: BrFalse(29)
B2:
	13: Branch(14)
B3:
	14: MutBorrowLoc[4](loc3: vector<u8>)
	15: ImmBorrowLoc[1](loc0: vector<vector<u8>>)
	16: ImmBorrowLoc[0](Arg0: vector<u8>)
	17: CopyLoc[2](loc1: u64)
	18: VecImmBorrow(1)
	19: ReadRef
	20: CastU64
	21: VecImmBorrow(0)
	22: ReadRef
	23: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	24: MoveLoc[2](loc1: u64)
	25: LdU64(1)
	26: Add
	27: StLoc[2](loc1: u64)
	28: Branch(9)
B4:
	29: MoveLoc[4](loc3: vector<u8>)
	30: Ret
}

public decode(Arg0: vector<u8>): vector<u8> {
L1:	loc0: u8
L2:	loc1: u64
L3:	loc2: u64
L4:	loc3: vector<u8>
B0:
	0: LdU64(0)
	1: LdConst[3](vector<u8>: "" /..)
	2: ImmBorrowLoc[0](Arg0: vector<u8>)
	3: VecLen(1)
	4: StLoc[3](loc2: u64)
	5: StLoc[4](loc3: vector<u8>)
	6: StLoc[2](loc1: u64)
	7: CopyLoc[3](loc2: u64)
	8: LdU64(2)
	9: Mod
	10: LdU64(0)
	11: Eq
	12: BrFalse(14)
B1:
	13: Branch(16)
B2:
	14: LdConst[0](u64: 0)
	15: Abort
B3:
	16: CopyLoc[2](loc1: u64)
	17: CopyLoc[3](loc2: u64)
	18: Lt
	19: BrFalse(44)
B4:
	20: ImmBorrowLoc[0](Arg0: vector<u8>)
	21: CopyLoc[2](loc1: u64)
	22: VecImmBorrow(1)
	23: ReadRef
	24: Call decode_byte(u8): u8
	25: LdU8(16)
	26: Mul
	27: ImmBorrowLoc[0](Arg0: vector<u8>)
	28: CopyLoc[2](loc1: u64)
	29: LdU64(1)
	30: Add
	31: VecImmBorrow(1)
	32: ReadRef
	33: Call decode_byte(u8): u8
	34: Add
	35: StLoc[1](loc0: u8)
	36: MutBorrowLoc[4](loc3: vector<u8>)
	37: MoveLoc[1](loc0: u8)
	38: VecPushBack(1)
	39: MoveLoc[2](loc1: u64)
	40: LdU64(2)
	41: Add
	42: StLoc[2](loc1: u64)
	43: Branch(16)
B5:
	44: MoveLoc[4](loc3: vector<u8>)
	45: Ret
}

decode_byte(Arg0: u8): u8 {
L1:	loc0: bool
L2:	loc1: bool
L3:	loc2: bool
L4:	loc3: u8
L5:	loc4: u8
B0:
	0: LdU8(48)
	1: CopyLoc[0](Arg0: u8)
	2: Le
	3: BrFalse(9)
B1:
	4: CopyLoc[0](Arg0: u8)
	5: LdU8(58)
	6: Lt
	7: StLoc[1](loc0: bool)
	8: Branch(11)
B2:
	9: LdFalse
	10: StLoc[1](loc0: bool)
B3:
	11: MoveLoc[1](loc0: bool)
	12: BrFalse(18)
B4:
	13: MoveLoc[0](Arg0: u8)
	14: LdU8(48)
	15: Sub
	16: StLoc[5](loc4: u8)
	17: Branch(62)
B5:
	18: LdU8(65)
	19: CopyLoc[0](Arg0: u8)
	20: Le
	21: BrFalse(27)
B6:
	22: CopyLoc[0](Arg0: u8)
	23: LdU8(71)
	24: Lt
	25: StLoc[2](loc1: bool)
	26: Branch(29)
B7:
	27: LdFalse
	28: StLoc[2](loc1: bool)
B8:
	29: MoveLoc[2](loc1: bool)
	30: BrFalse(38)
B9:
	31: LdU8(10)
	32: MoveLoc[0](Arg0: u8)
	33: Add
	34: LdU8(65)
	35: Sub
	36: StLoc[4](loc3: u8)
	37: Branch(60)
B10:
	38: LdU8(97)
	39: CopyLoc[0](Arg0: u8)
	40: Le
	41: BrFalse(47)
B11:
	42: CopyLoc[0](Arg0: u8)
	43: LdU8(103)
	44: Lt
	45: StLoc[3](loc2: bool)
	46: Branch(49)
B12:
	47: LdFalse
	48: StLoc[3](loc2: bool)
B13:
	49: MoveLoc[3](loc2: bool)
	50: BrFalse(52)
B14:
	51: Branch(54)
B15:
	52: LdConst[1](u64: 1)
	53: Abort
B16:
	54: LdU8(10)
	55: MoveLoc[0](Arg0: u8)
	56: Add
	57: LdU8(97)
	58: Sub
	59: StLoc[4](loc3: u8)
B17:
	60: MoveLoc[4](loc3: u8)
	61: StLoc[5](loc4: u8)
B18:
	62: MoveLoc[5](loc4: u8)
	63: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => vector<vector<u8>>: 8002023030023031023032023033023034023035023036023037023038023039023061023062023063023064023065023066023130023131023132023133023134023135023136023137023138023139023161023162023163023164023165023166023230023231023232023233023234023235023236023237023238023239023261023262023263023264023265023266023330023331023332023333023334023335023336023337023338023339023361023362023363023364023365023366023430023431023432023433023434023435023436023437023438023439023461023462023463023464023465023466023530023531023532023533023534023535023536023537023538023539023561023562023563023564023565023566023630023631023632023633023634023635023636023637023638023639023661023662023663023664023665023666023730023731023732023733023734023735023736023737023738023739023761023762023763023764023765023766023830023831023832023833023834023835023836023837023838023839023861023862023863023864023865023866023930023931023932023933023934023935023936023937023938023939023961023962023963023964023965023966026130026131026132026133026134026135026136026137026138026139026161026162026163026164026165026166026230026231026232026233026234026235026236026237026238026239026261026262026263026264026265026266026330026331026332026333026334026335026336026337026338026339026361026362026363026364026365026366026430026431026432026433026434026435026436026437026438026439026461026462026463026464026465026466026530026531026532026533026534026535026536026537026538026539026561026562026563026564026565026566026630026631026632026633026634026635026636026637026638026639026661026662026663026664026665026666
	3 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 2.hmac {

native public hmac_sha3_256(Arg0: &vector<u8>, Arg1: &vector<u8>): vector<u8>;

}

// Move bytecode v6
module 2.kiosk {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer_policy;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct Kiosk has store, key {
	id: UID,
	profits: Balance<SAFE>,
	owner: address,
	item_count: u32,
	allow_extensions: bool
}

struct KioskOwnerCap has store, key {
	id: UID,
	for: ID
}

struct PurchaseCap<phantom Ty0: store + key> has store, key {
	id: UID,
	kiosk_id: ID,
	item_id: ID,
	min_price: u64
}

struct Borrow {
	kiosk_id: ID,
	item_id: ID
}

struct Item has copy, drop, store {
	id: ID
}

struct Listing has copy, drop, store {
	id: ID,
	is_exclusive: bool
}

struct Lock has copy, drop, store {
	id: ID
}

struct ItemListed<phantom Ty0: store + key> has copy, drop {
	kiosk: ID,
	id: ID,
	price: u64
}

struct ItemPurchased<phantom Ty0: store + key> has copy, drop {
	kiosk: ID,
	id: ID,
	price: u64
}

struct ItemDelisted<phantom Ty0: store + key> has copy, drop {
	kiosk: ID,
	id: ID
}

entry default(Arg0: &mut TxContext) {
L1:	loc0: KioskOwnerCap
L2:	loc1: Kiosk
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call new(&mut TxContext): Kiosk * KioskOwnerCap
	2: StLoc[1](loc0: KioskOwnerCap)
	3: StLoc[2](loc1: Kiosk)
	4: MoveLoc[1](loc0: KioskOwnerCap)
	5: MoveLoc[0](Arg0: &mut TxContext)
	6: FreezeRef
	7: Call tx_context::sender(&TxContext): address
	8: Call transfer::transfer<KioskOwnerCap>(KioskOwnerCap, address)
	9: MoveLoc[2](loc1: Kiosk)
	10: Call transfer::share_object<Kiosk>(Kiosk)
	11: Ret
}

public new(Arg0: &mut TxContext): Kiosk * KioskOwnerCap {
L1:	loc0: KioskOwnerCap
L2:	loc1: Kiosk
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Call balance::zero<SAFE>(): Balance<SAFE>
	3: CopyLoc[0](Arg0: &mut TxContext)
	4: FreezeRef
	5: Call tx_context::sender(&TxContext): address
	6: LdU32(0)
	7: LdFalse
	8: Pack[0](Kiosk)
	9: StLoc[2](loc1: Kiosk)
	10: MoveLoc[0](Arg0: &mut TxContext)
	11: Call object::new(&mut TxContext): UID
	12: ImmBorrowLoc[2](loc1: Kiosk)
	13: Call object::id<Kiosk>(&Kiosk): ID
	14: Pack[1](KioskOwnerCap)
	15: StLoc[1](loc0: KioskOwnerCap)
	16: MoveLoc[2](loc1: Kiosk)
	17: MoveLoc[1](loc0: KioskOwnerCap)
	18: Ret
}

public close_and_withdraw(Arg0: Kiosk, Arg1: KioskOwnerCap, Arg2: &mut TxContext): Coin<SAFE> {
L3:	loc0: UID
L4:	loc1: ID
L5:	loc2: UID
L6:	loc3: u32
L7:	loc4: Balance<SAFE>
B0:
	0: MoveLoc[0](Arg0: Kiosk)
	1: Unpack[0](Kiosk)
	2: Pop
	3: StLoc[6](loc3: u32)
	4: Pop
	5: StLoc[7](loc4: Balance<SAFE>)
	6: StLoc[5](loc2: UID)
	7: MoveLoc[1](Arg1: KioskOwnerCap)
	8: Unpack[1](KioskOwnerCap)
	9: StLoc[4](loc1: ID)
	10: StLoc[3](loc0: UID)
	11: ImmBorrowLoc[5](loc2: UID)
	12: Call object::uid_to_inner(&UID): ID
	13: MoveLoc[4](loc1: ID)
	14: Eq
	15: BrFalse(17)
B1:
	16: Branch(21)
B2:
	17: MoveLoc[2](Arg2: &mut TxContext)
	18: Pop
	19: LdConst[0](u64: 0)
	20: Abort
B3:
	21: MoveLoc[6](loc3: u32)
	22: LdU32(0)
	23: Eq
	24: BrFalse(26)
B4:
	25: Branch(30)
B5:
	26: MoveLoc[2](Arg2: &mut TxContext)
	27: Pop
	28: LdConst[3](u64: 3)
	29: Abort
B6:
	30: MoveLoc[3](loc0: UID)
	31: Call object::delete(UID)
	32: MoveLoc[5](loc2: UID)
	33: Call object::delete(UID)
	34: MoveLoc[7](loc4: Balance<SAFE>)
	35: MoveLoc[2](Arg2: &mut TxContext)
	36: Call coin::from_balance<SAFE>(Balance<SAFE>, &mut TxContext): Coin<SAFE>
	37: Ret
}

public set_owner(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: &TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: MoveLoc[2](Arg2: &TxContext)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[2](Arg2: &TxContext)
	12: Call tx_context::sender(&TxContext): address
	13: MoveLoc[0](Arg0: &mut Kiosk)
	14: MutBorrowField[0](Kiosk.owner: address)
	15: WriteRef
	16: Ret
}

public set_owner_custom(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: address) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[2](Arg2: address)
	10: MoveLoc[0](Arg0: &mut Kiosk)
	11: MutBorrowField[0](Kiosk.owner: address)
	12: WriteRef
	13: Ret
}

public place<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: Ty0) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Kiosk)
	10: MoveLoc[2](Arg2: Ty0)
	11: Call place_internal<Ty0>(&mut Kiosk, Ty0)
	12: Ret
}

public lock<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: &TransferPolicy<Ty0>, Arg3: Ty0) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Kiosk)
	10: MoveLoc[3](Arg3: Ty0)
	11: Call lock_internal<Ty0>(&mut Kiosk, Ty0)
	12: Ret
}

public take<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID): Ty0 {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: CopyLoc[2](Arg2: ID)
	12: Call is_locked(&Kiosk, ID): bool
	13: Not
	14: BrFalse(16)
B4:
	15: Branch(20)
B5:
	16: MoveLoc[0](Arg0: &mut Kiosk)
	17: Pop
	18: LdConst[8](u64: 8)
	19: Abort
B6:
	20: CopyLoc[0](Arg0: &mut Kiosk)
	21: FreezeRef
	22: CopyLoc[2](Arg2: ID)
	23: Call is_listed_exclusively(&Kiosk, ID): bool
	24: Not
	25: BrFalse(27)
B7:
	26: Branch(31)
B8:
	27: MoveLoc[0](Arg0: &mut Kiosk)
	28: Pop
	29: LdConst[4](u64: 4)
	30: Abort
B9:
	31: CopyLoc[0](Arg0: &mut Kiosk)
	32: FreezeRef
	33: CopyLoc[2](Arg2: ID)
	34: Call has_item(&Kiosk, ID): bool
	35: BrFalse(37)
B10:
	36: Branch(41)
B11:
	37: MoveLoc[0](Arg0: &mut Kiosk)
	38: Pop
	39: LdConst[11](u64: 11)
	40: Abort
B12:
	41: CopyLoc[0](Arg0: &mut Kiosk)
	42: ImmBorrowField[1](Kiosk.item_count: u32)
	43: ReadRef
	44: LdU32(1)
	45: Sub
	46: CopyLoc[0](Arg0: &mut Kiosk)
	47: MutBorrowField[1](Kiosk.item_count: u32)
	48: WriteRef
	49: CopyLoc[0](Arg0: &mut Kiosk)
	50: MutBorrowField[2](Kiosk.id: UID)
	51: CopyLoc[2](Arg2: ID)
	52: LdFalse
	53: Pack[5](Listing)
	54: Call dynamic_field::remove_if_exists<Listing, u64>(&mut UID, Listing): Option<u64>
	55: Pop
	56: MoveLoc[0](Arg0: &mut Kiosk)
	57: MutBorrowField[2](Kiosk.id: UID)
	58: MoveLoc[2](Arg2: ID)
	59: Pack[4](Item)
	60: Call dynamic_object_field::remove<Item, Ty0>(&mut UID, Item): Ty0
	61: Ret
}

public list<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID, Arg3: u64) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: CopyLoc[2](Arg2: ID)
	12: Call has_item_with_type<Ty0>(&Kiosk, ID): bool
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Kiosk)
	16: Pop
	17: LdConst[11](u64: 11)
	18: Abort
B6:
	19: CopyLoc[0](Arg0: &mut Kiosk)
	20: FreezeRef
	21: CopyLoc[2](Arg2: ID)
	22: Call is_listed_exclusively(&Kiosk, ID): bool
	23: Not
	24: BrFalse(26)
B7:
	25: Branch(30)
B8:
	26: MoveLoc[0](Arg0: &mut Kiosk)
	27: Pop
	28: LdConst[4](u64: 4)
	29: Abort
B9:
	30: CopyLoc[0](Arg0: &mut Kiosk)
	31: MutBorrowField[2](Kiosk.id: UID)
	32: CopyLoc[2](Arg2: ID)
	33: LdFalse
	34: Pack[5](Listing)
	35: CopyLoc[3](Arg3: u64)
	36: Call dynamic_field::add<Listing, u64>(&mut UID, Listing, u64)
	37: MoveLoc[0](Arg0: &mut Kiosk)
	38: FreezeRef
	39: Call object::id<Kiosk>(&Kiosk): ID
	40: MoveLoc[2](Arg2: ID)
	41: MoveLoc[3](Arg3: u64)
	42: PackGeneric[0](ItemListed<Ty0>)
	43: Call event::emit<ItemListed<Ty0>>(ItemListed<Ty0>)
	44: Ret
}

public place_and_list<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: Ty0, Arg3: u64) {
L4:	loc0: ID
B0:
	0: ImmBorrowLoc[2](Arg2: Ty0)
	1: Call object::id<Ty0>(&Ty0): ID
	2: StLoc[4](loc0: ID)
	3: CopyLoc[0](Arg0: &mut Kiosk)
	4: CopyLoc[1](Arg1: &KioskOwnerCap)
	5: MoveLoc[2](Arg2: Ty0)
	6: Call place<Ty0>(&mut Kiosk, &KioskOwnerCap, Ty0)
	7: MoveLoc[0](Arg0: &mut Kiosk)
	8: MoveLoc[1](Arg1: &KioskOwnerCap)
	9: MoveLoc[4](loc0: ID)
	10: MoveLoc[3](Arg3: u64)
	11: Call list<Ty0>(&mut Kiosk, &KioskOwnerCap, ID, u64)
	12: Ret
}

public delist<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: CopyLoc[2](Arg2: ID)
	12: Call has_item_with_type<Ty0>(&Kiosk, ID): bool
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Kiosk)
	16: Pop
	17: LdConst[11](u64: 11)
	18: Abort
B6:
	19: CopyLoc[0](Arg0: &mut Kiosk)
	20: FreezeRef
	21: CopyLoc[2](Arg2: ID)
	22: Call is_listed_exclusively(&Kiosk, ID): bool
	23: Not
	24: BrFalse(26)
B7:
	25: Branch(30)
B8:
	26: MoveLoc[0](Arg0: &mut Kiosk)
	27: Pop
	28: LdConst[4](u64: 4)
	29: Abort
B9:
	30: CopyLoc[0](Arg0: &mut Kiosk)
	31: FreezeRef
	32: CopyLoc[2](Arg2: ID)
	33: Call is_listed(&Kiosk, ID): bool
	34: BrFalse(36)
B10:
	35: Branch(40)
B11:
	36: MoveLoc[0](Arg0: &mut Kiosk)
	37: Pop
	38: LdConst[12](u64: 12)
	39: Abort
B12:
	40: CopyLoc[0](Arg0: &mut Kiosk)
	41: MutBorrowField[2](Kiosk.id: UID)
	42: CopyLoc[2](Arg2: ID)
	43: LdFalse
	44: Pack[5](Listing)
	45: Call dynamic_field::remove<Listing, u64>(&mut UID, Listing): u64
	46: Pop
	47: MoveLoc[0](Arg0: &mut Kiosk)
	48: FreezeRef
	49: Call object::id<Kiosk>(&Kiosk): ID
	50: MoveLoc[2](Arg2: ID)
	51: PackGeneric[1](ItemDelisted<Ty0>)
	52: Call event::emit<ItemDelisted<Ty0>>(ItemDelisted<Ty0>)
	53: Ret
}

public purchase<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: ID, Arg2: Coin<SAFE>): Ty0 * TransferRequest<Ty0> {
L3:	loc0: Ty0
L4:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MutBorrowField[2](Kiosk.id: UID)
	2: CopyLoc[1](Arg1: ID)
	3: LdFalse
	4: Pack[5](Listing)
	5: Call dynamic_field::remove<Listing, u64>(&mut UID, Listing): u64
	6: StLoc[4](loc1: u64)
	7: CopyLoc[0](Arg0: &mut Kiosk)
	8: MutBorrowField[2](Kiosk.id: UID)
	9: CopyLoc[1](Arg1: ID)
	10: Pack[4](Item)
	11: Call dynamic_object_field::remove<Item, Ty0>(&mut UID, Item): Ty0
	12: StLoc[3](loc0: Ty0)
	13: CopyLoc[0](Arg0: &mut Kiosk)
	14: ImmBorrowField[1](Kiosk.item_count: u32)
	15: ReadRef
	16: LdU32(1)
	17: Sub
	18: CopyLoc[0](Arg0: &mut Kiosk)
	19: MutBorrowField[1](Kiosk.item_count: u32)
	20: WriteRef
	21: CopyLoc[4](loc1: u64)
	22: ImmBorrowLoc[2](Arg2: Coin<SAFE>)
	23: Call coin::value<SAFE>(&Coin<SAFE>): u64
	24: Eq
	25: BrFalse(27)
B1:
	26: Branch(31)
B2:
	27: MoveLoc[0](Arg0: &mut Kiosk)
	28: Pop
	29: LdConst[1](u64: 1)
	30: Abort
B3:
	31: CopyLoc[0](Arg0: &mut Kiosk)
	32: MutBorrowField[2](Kiosk.id: UID)
	33: CopyLoc[1](Arg1: ID)
	34: Pack[6](Lock)
	35: Call dynamic_field::remove_if_exists<Lock, bool>(&mut UID, Lock): Option<bool>
	36: Pop
	37: CopyLoc[0](Arg0: &mut Kiosk)
	38: MutBorrowField[3](Kiosk.profits: Balance<SAFE>)
	39: MoveLoc[2](Arg2: Coin<SAFE>)
	40: Call coin::put<SAFE>(&mut Balance<SAFE>, Coin<SAFE>)
	41: CopyLoc[0](Arg0: &mut Kiosk)
	42: FreezeRef
	43: Call object::id<Kiosk>(&Kiosk): ID
	44: CopyLoc[1](Arg1: ID)
	45: CopyLoc[4](loc1: u64)
	46: PackGeneric[2](ItemPurchased<Ty0>)
	47: Call event::emit<ItemPurchased<Ty0>>(ItemPurchased<Ty0>)
	48: MoveLoc[3](loc0: Ty0)
	49: MoveLoc[1](Arg1: ID)
	50: MoveLoc[4](loc1: u64)
	51: MoveLoc[0](Arg0: &mut Kiosk)
	52: FreezeRef
	53: Call object::id<Kiosk>(&Kiosk): ID
	54: Call transfer_policy::new_request<Ty0>(ID, u64, ID): TransferRequest<Ty0>
	55: Ret
}

public list_with_purchase_cap<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID, Arg3: u64, Arg4: &mut TxContext): PurchaseCap<Ty0> {
L5:	loc0: u64
L6:	loc1: ID
L7:	loc2: UID
L8:	loc3: ID
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: MoveLoc[4](Arg4: &mut TxContext)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut Kiosk)
	12: FreezeRef
	13: CopyLoc[2](Arg2: ID)
	14: Call has_item_with_type<Ty0>(&Kiosk, ID): bool
	15: BrFalse(17)
B4:
	16: Branch(23)
B5:
	17: MoveLoc[0](Arg0: &mut Kiosk)
	18: Pop
	19: MoveLoc[4](Arg4: &mut TxContext)
	20: Pop
	21: LdConst[11](u64: 11)
	22: Abort
B6:
	23: CopyLoc[0](Arg0: &mut Kiosk)
	24: FreezeRef
	25: CopyLoc[2](Arg2: ID)
	26: Call is_listed(&Kiosk, ID): bool
	27: Not
	28: BrFalse(30)
B7:
	29: Branch(36)
B8:
	30: MoveLoc[0](Arg0: &mut Kiosk)
	31: Pop
	32: MoveLoc[4](Arg4: &mut TxContext)
	33: Pop
	34: LdConst[6](u64: 6)
	35: Abort
B9:
	36: CopyLoc[0](Arg0: &mut Kiosk)
	37: MutBorrowField[2](Kiosk.id: UID)
	38: CopyLoc[2](Arg2: ID)
	39: LdTrue
	40: Pack[5](Listing)
	41: CopyLoc[3](Arg3: u64)
	42: Call dynamic_field::add<Listing, u64>(&mut UID, Listing, u64)
	43: MoveLoc[3](Arg3: u64)
	44: StLoc[5](loc0: u64)
	45: MoveLoc[2](Arg2: ID)
	46: StLoc[6](loc1: ID)
	47: MoveLoc[4](Arg4: &mut TxContext)
	48: Call object::new(&mut TxContext): UID
	49: StLoc[7](loc2: UID)
	50: MoveLoc[0](Arg0: &mut Kiosk)
	51: FreezeRef
	52: Call object::id<Kiosk>(&Kiosk): ID
	53: StLoc[8](loc3: ID)
	54: MoveLoc[7](loc2: UID)
	55: MoveLoc[8](loc3: ID)
	56: MoveLoc[6](loc1: ID)
	57: MoveLoc[5](loc0: u64)
	58: PackGeneric[3](PurchaseCap<Ty0>)
	59: Ret
}

public purchase_with_cap<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: PurchaseCap<Ty0>, Arg2: Coin<SAFE>): Ty0 * TransferRequest<Ty0> {
L3:	loc0: ID
L4:	loc1: ID
L5:	loc2: ID
L6:	loc3: u64
L7:	loc4: u64
B0:
	0: MoveLoc[1](Arg1: PurchaseCap<Ty0>)
	1: UnpackGeneric[3](PurchaseCap<Ty0>)
	2: StLoc[6](loc3: u64)
	3: StLoc[4](loc1: ID)
	4: StLoc[5](loc2: ID)
	5: Call object::delete(UID)
	6: MoveLoc[4](loc1: ID)
	7: StLoc[3](loc0: ID)
	8: ImmBorrowLoc[2](Arg2: Coin<SAFE>)
	9: Call coin::value<SAFE>(&Coin<SAFE>): u64
	10: StLoc[7](loc4: u64)
	11: CopyLoc[7](loc4: u64)
	12: MoveLoc[6](loc3: u64)
	13: Ge
	14: BrFalse(16)
B1:
	15: Branch(20)
B2:
	16: MoveLoc[0](Arg0: &mut Kiosk)
	17: Pop
	18: LdConst[1](u64: 1)
	19: Abort
B3:
	20: CopyLoc[0](Arg0: &mut Kiosk)
	21: FreezeRef
	22: Call object::id<Kiosk>(&Kiosk): ID
	23: MoveLoc[5](loc2: ID)
	24: Eq
	25: BrFalse(27)
B4:
	26: Branch(31)
B5:
	27: MoveLoc[0](Arg0: &mut Kiosk)
	28: Pop
	29: LdConst[5](u64: 5)
	30: Abort
B6:
	31: CopyLoc[0](Arg0: &mut Kiosk)
	32: MutBorrowField[2](Kiosk.id: UID)
	33: CopyLoc[3](loc0: ID)
	34: LdTrue
	35: Pack[5](Listing)
	36: Call dynamic_field::remove<Listing, u64>(&mut UID, Listing): u64
	37: Pop
	38: CopyLoc[0](Arg0: &mut Kiosk)
	39: MutBorrowField[3](Kiosk.profits: Balance<SAFE>)
	40: MoveLoc[2](Arg2: Coin<SAFE>)
	41: Call coin::put<SAFE>(&mut Balance<SAFE>, Coin<SAFE>)
	42: CopyLoc[0](Arg0: &mut Kiosk)
	43: ImmBorrowField[1](Kiosk.item_count: u32)
	44: ReadRef
	45: LdU32(1)
	46: Sub
	47: CopyLoc[0](Arg0: &mut Kiosk)
	48: MutBorrowField[1](Kiosk.item_count: u32)
	49: WriteRef
	50: CopyLoc[0](Arg0: &mut Kiosk)
	51: MutBorrowField[2](Kiosk.id: UID)
	52: CopyLoc[3](loc0: ID)
	53: Pack[6](Lock)
	54: Call dynamic_field::remove_if_exists<Lock, bool>(&mut UID, Lock): Option<bool>
	55: Pop
	56: CopyLoc[0](Arg0: &mut Kiosk)
	57: MutBorrowField[2](Kiosk.id: UID)
	58: CopyLoc[3](loc0: ID)
	59: Pack[4](Item)
	60: Call dynamic_object_field::remove<Item, Ty0>(&mut UID, Item): Ty0
	61: MoveLoc[3](loc0: ID)
	62: MoveLoc[7](loc4: u64)
	63: MoveLoc[0](Arg0: &mut Kiosk)
	64: FreezeRef
	65: Call object::id<Kiosk>(&Kiosk): ID
	66: Call transfer_policy::new_request<Ty0>(ID, u64, ID): TransferRequest<Ty0>
	67: Ret
}

public return_purchase_cap<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: PurchaseCap<Ty0>) {
L2:	loc0: UID
L3:	loc1: ID
L4:	loc2: ID
B0:
	0: MoveLoc[1](Arg1: PurchaseCap<Ty0>)
	1: UnpackGeneric[3](PurchaseCap<Ty0>)
	2: Pop
	3: StLoc[3](loc1: ID)
	4: StLoc[4](loc2: ID)
	5: StLoc[2](loc0: UID)
	6: CopyLoc[0](Arg0: &mut Kiosk)
	7: FreezeRef
	8: Call object::id<Kiosk>(&Kiosk): ID
	9: MoveLoc[4](loc2: ID)
	10: Eq
	11: BrFalse(13)
B1:
	12: Branch(17)
B2:
	13: MoveLoc[0](Arg0: &mut Kiosk)
	14: Pop
	15: LdConst[5](u64: 5)
	16: Abort
B3:
	17: MoveLoc[0](Arg0: &mut Kiosk)
	18: MutBorrowField[2](Kiosk.id: UID)
	19: MoveLoc[3](loc1: ID)
	20: LdTrue
	21: Pack[5](Listing)
	22: Call dynamic_field::remove<Listing, u64>(&mut UID, Listing): u64
	23: Pop
	24: MoveLoc[2](loc0: UID)
	25: Call object::delete(UID)
	26: Ret
}

public withdraw(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: Option<u64>, Arg3: &mut TxContext): Coin<SAFE> {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: u64
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: MoveLoc[3](Arg3: &mut TxContext)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: ImmBorrowLoc[2](Arg2: Option<u64>)
	12: Call option::is_some<u64>(&Option<u64>): bool
	13: BrFalse(33)
B4:
	14: MoveLoc[2](Arg2: Option<u64>)
	15: Call option::destroy_some<u64>(Option<u64>): u64
	16: StLoc[6](loc2: u64)
	17: CopyLoc[6](loc2: u64)
	18: CopyLoc[0](Arg0: &mut Kiosk)
	19: ImmBorrowField[3](Kiosk.profits: Balance<SAFE>)
	20: Call balance::value<SAFE>(&Balance<SAFE>): u64
	21: Le
	22: BrFalse(24)
B5:
	23: Branch(30)
B6:
	24: MoveLoc[0](Arg0: &mut Kiosk)
	25: Pop
	26: MoveLoc[3](Arg3: &mut TxContext)
	27: Pop
	28: LdConst[2](u64: 2)
	29: Abort
B7:
	30: MoveLoc[6](loc2: u64)
	31: StLoc[4](loc0: u64)
	32: Branch(37)
B8:
	33: CopyLoc[0](Arg0: &mut Kiosk)
	34: ImmBorrowField[3](Kiosk.profits: Balance<SAFE>)
	35: Call balance::value<SAFE>(&Balance<SAFE>): u64
	36: StLoc[4](loc0: u64)
B9:
	37: MoveLoc[4](loc0: u64)
	38: StLoc[5](loc1: u64)
	39: MoveLoc[0](Arg0: &mut Kiosk)
	40: MutBorrowField[3](Kiosk.profits: Balance<SAFE>)
	41: MoveLoc[5](loc1: u64)
	42: MoveLoc[3](Arg3: &mut TxContext)
	43: Call coin::take<SAFE>(&mut Balance<SAFE>, u64, &mut TxContext): Coin<SAFE>
	44: Ret
}

public(friend) lock_internal<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: Ty0) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MutBorrowField[2](Kiosk.id: UID)
	2: ImmBorrowLoc[1](Arg1: Ty0)
	3: Call object::id<Ty0>(&Ty0): ID
	4: Pack[6](Lock)
	5: LdTrue
	6: Call dynamic_field::add<Lock, bool>(&mut UID, Lock, bool)
	7: MoveLoc[0](Arg0: &mut Kiosk)
	8: MoveLoc[1](Arg1: Ty0)
	9: Call place_internal<Ty0>(&mut Kiosk, Ty0)
	10: Ret
}

public(friend) place_internal<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: Ty0) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: ImmBorrowField[1](Kiosk.item_count: u32)
	2: ReadRef
	3: LdU32(1)
	4: Add
	5: CopyLoc[0](Arg0: &mut Kiosk)
	6: MutBorrowField[1](Kiosk.item_count: u32)
	7: WriteRef
	8: MoveLoc[0](Arg0: &mut Kiosk)
	9: MutBorrowField[2](Kiosk.id: UID)
	10: ImmBorrowLoc[1](Arg1: Ty0)
	11: Call object::id<Ty0>(&Ty0): ID
	12: Pack[4](Item)
	13: MoveLoc[1](Arg1: Ty0)
	14: Call dynamic_object_field::add<Item, Ty0>(&mut UID, Item, Ty0)
	15: Ret
}

public(friend) uid_mut_internal(Arg0: &mut Kiosk): &mut UID {
B0:
	0: MoveLoc[0](Arg0: &mut Kiosk)
	1: MutBorrowField[2](Kiosk.id: UID)
	2: Ret
}

public has_item(Arg0: &Kiosk, Arg1: ID): bool {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[2](Kiosk.id: UID)
	2: MoveLoc[1](Arg1: ID)
	3: Pack[4](Item)
	4: Call dynamic_object_field::exists_<Item>(&UID, Item): bool
	5: Ret
}

public has_item_with_type<Ty0: store + key>(Arg0: &Kiosk, Arg1: ID): bool {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[2](Kiosk.id: UID)
	2: MoveLoc[1](Arg1: ID)
	3: Pack[4](Item)
	4: Call dynamic_object_field::exists_with_type<Item, Ty0>(&UID, Item): bool
	5: Ret
}

public is_locked(Arg0: &Kiosk, Arg1: ID): bool {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[2](Kiosk.id: UID)
	2: MoveLoc[1](Arg1: ID)
	3: Pack[6](Lock)
	4: Call dynamic_field::exists_<Lock>(&UID, Lock): bool
	5: Ret
}

public is_listed(Arg0: &Kiosk, Arg1: ID): bool {
L2:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[2](Kiosk.id: UID)
	2: CopyLoc[1](Arg1: ID)
	3: LdFalse
	4: Pack[5](Listing)
	5: Call dynamic_field::exists_<Listing>(&UID, Listing): bool
	6: BrFalse(12)
B1:
	7: MoveLoc[0](Arg0: &Kiosk)
	8: Pop
	9: LdTrue
	10: StLoc[2](loc0: bool)
	11: Branch(16)
B2:
	12: MoveLoc[0](Arg0: &Kiosk)
	13: MoveLoc[1](Arg1: ID)
	14: Call is_listed_exclusively(&Kiosk, ID): bool
	15: StLoc[2](loc0: bool)
B3:
	16: MoveLoc[2](loc0: bool)
	17: Ret
}

public is_listed_exclusively(Arg0: &Kiosk, Arg1: ID): bool {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[2](Kiosk.id: UID)
	2: MoveLoc[1](Arg1: ID)
	3: LdTrue
	4: Pack[5](Listing)
	5: Call dynamic_field::exists_<Listing>(&UID, Listing): bool
	6: Ret
}

public has_access(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap): bool {
B0:
	0: MoveLoc[0](Arg0: &mut Kiosk)
	1: FreezeRef
	2: Call object::id<Kiosk>(&Kiosk): ID
	3: MoveLoc[1](Arg1: &KioskOwnerCap)
	4: ImmBorrowField[4](KioskOwnerCap.for: ID)
	5: ReadRef
	6: Eq
	7: Ret
}

public uid_mut_as_owner(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap): &mut UID {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Kiosk)
	10: MutBorrowField[2](Kiosk.id: UID)
	11: Ret
}

public set_allow_extensions(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: bool) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[2](Arg2: bool)
	10: MoveLoc[0](Arg0: &mut Kiosk)
	11: MutBorrowField[5](Kiosk.allow_extensions: bool)
	12: WriteRef
	13: Ret
}

public uid(Arg0: &Kiosk): &UID {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[2](Kiosk.id: UID)
	2: Ret
}

public uid_mut(Arg0: &mut Kiosk): &mut UID {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: ImmBorrowField[5](Kiosk.allow_extensions: bool)
	2: ReadRef
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[7](u64: 7)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Kiosk)
	10: MutBorrowField[2](Kiosk.id: UID)
	11: Ret
}

public owner(Arg0: &Kiosk): address {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[0](Kiosk.owner: address)
	2: ReadRef
	3: Ret
}

public item_count(Arg0: &Kiosk): u32 {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[1](Kiosk.item_count: u32)
	2: ReadRef
	3: Ret
}

public profits_amount(Arg0: &Kiosk): u64 {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: ImmBorrowField[3](Kiosk.profits: Balance<SAFE>)
	2: Call balance::value<SAFE>(&Balance<SAFE>): u64
	3: Ret
}

public profits_mut(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap): &mut Balance<SAFE> {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: MoveLoc[0](Arg0: &mut Kiosk)
	10: MutBorrowField[3](Kiosk.profits: Balance<SAFE>)
	11: Ret
}

public borrow<Ty0: store + key>(Arg0: &Kiosk, Arg1: &KioskOwnerCap, Arg2: ID): &Ty0 {
B0:
	0: CopyLoc[0](Arg0: &Kiosk)
	1: Call object::id<Kiosk>(&Kiosk): ID
	2: MoveLoc[1](Arg1: &KioskOwnerCap)
	3: ImmBorrowField[4](KioskOwnerCap.for: ID)
	4: ReadRef
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[0](Arg0: &Kiosk)
	9: Pop
	10: LdConst[0](u64: 0)
	11: Abort
B3:
	12: CopyLoc[0](Arg0: &Kiosk)
	13: CopyLoc[2](Arg2: ID)
	14: Call has_item(&Kiosk, ID): bool
	15: BrFalse(17)
B4:
	16: Branch(21)
B5:
	17: MoveLoc[0](Arg0: &Kiosk)
	18: Pop
	19: LdConst[11](u64: 11)
	20: Abort
B6:
	21: MoveLoc[0](Arg0: &Kiosk)
	22: ImmBorrowField[2](Kiosk.id: UID)
	23: MoveLoc[2](Arg2: ID)
	24: Pack[4](Item)
	25: Call dynamic_object_field::borrow<Item, Ty0>(&UID, Item): &Ty0
	26: Ret
}

public borrow_mut<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID): &mut Ty0 {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: CopyLoc[2](Arg2: ID)
	12: Call has_item(&Kiosk, ID): bool
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Kiosk)
	16: Pop
	17: LdConst[11](u64: 11)
	18: Abort
B6:
	19: CopyLoc[0](Arg0: &mut Kiosk)
	20: FreezeRef
	21: CopyLoc[2](Arg2: ID)
	22: Call is_listed(&Kiosk, ID): bool
	23: Not
	24: BrFalse(26)
B7:
	25: Branch(30)
B8:
	26: MoveLoc[0](Arg0: &mut Kiosk)
	27: Pop
	28: LdConst[9](u64: 9)
	29: Abort
B9:
	30: MoveLoc[0](Arg0: &mut Kiosk)
	31: MutBorrowField[2](Kiosk.id: UID)
	32: MoveLoc[2](Arg2: ID)
	33: Pack[4](Item)
	34: Call dynamic_object_field::borrow_mut<Item, Ty0>(&mut UID, Item): &mut Ty0
	35: Ret
}

public borrow_val<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID): Ty0 * Borrow {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: CopyLoc[2](Arg2: ID)
	12: Call has_item(&Kiosk, ID): bool
	13: BrFalse(15)
B4:
	14: Branch(19)
B5:
	15: MoveLoc[0](Arg0: &mut Kiosk)
	16: Pop
	17: LdConst[11](u64: 11)
	18: Abort
B6:
	19: CopyLoc[0](Arg0: &mut Kiosk)
	20: FreezeRef
	21: CopyLoc[2](Arg2: ID)
	22: Call is_listed(&Kiosk, ID): bool
	23: Not
	24: BrFalse(26)
B7:
	25: Branch(30)
B8:
	26: MoveLoc[0](Arg0: &mut Kiosk)
	27: Pop
	28: LdConst[9](u64: 9)
	29: Abort
B9:
	30: CopyLoc[0](Arg0: &mut Kiosk)
	31: MutBorrowField[2](Kiosk.id: UID)
	32: CopyLoc[2](Arg2: ID)
	33: Pack[4](Item)
	34: Call dynamic_object_field::remove<Item, Ty0>(&mut UID, Item): Ty0
	35: MoveLoc[0](Arg0: &mut Kiosk)
	36: FreezeRef
	37: Call object::id<Kiosk>(&Kiosk): ID
	38: MoveLoc[2](Arg2: ID)
	39: Pack[3](Borrow)
	40: Ret
}

public return_val<Ty0: store + key>(Arg0: &mut Kiosk, Arg1: Ty0, Arg2: Borrow) {
L3:	loc0: ID
L4:	loc1: ID
B0:
	0: MoveLoc[2](Arg2: Borrow)
	1: Unpack[3](Borrow)
	2: StLoc[3](loc0: ID)
	3: StLoc[4](loc1: ID)
	4: CopyLoc[0](Arg0: &mut Kiosk)
	5: FreezeRef
	6: Call object::id<Kiosk>(&Kiosk): ID
	7: MoveLoc[4](loc1: ID)
	8: Eq
	9: BrFalse(11)
B1:
	10: Branch(15)
B2:
	11: MoveLoc[0](Arg0: &mut Kiosk)
	12: Pop
	13: LdConst[5](u64: 5)
	14: Abort
B3:
	15: ImmBorrowLoc[1](Arg1: Ty0)
	16: Call object::id<Ty0>(&Ty0): ID
	17: CopyLoc[3](loc0: ID)
	18: Eq
	19: BrFalse(21)
B4:
	20: Branch(25)
B5:
	21: MoveLoc[0](Arg0: &mut Kiosk)
	22: Pop
	23: LdConst[10](u64: 10)
	24: Abort
B6:
	25: MoveLoc[0](Arg0: &mut Kiosk)
	26: MutBorrowField[2](Kiosk.id: UID)
	27: MoveLoc[3](loc0: ID)
	28: Pack[4](Item)
	29: MoveLoc[1](Arg1: Ty0)
	30: Call dynamic_object_field::add<Item, Ty0>(&mut UID, Item, Ty0)
	31: Ret
}

public kiosk_owner_cap_for(Arg0: &KioskOwnerCap): ID {
B0:
	0: MoveLoc[0](Arg0: &KioskOwnerCap)
	1: ImmBorrowField[4](KioskOwnerCap.for: ID)
	2: ReadRef
	3: Ret
}

public purchase_cap_kiosk<Ty0: store + key>(Arg0: &PurchaseCap<Ty0>): ID {
B0:
	0: MoveLoc[0](Arg0: &PurchaseCap<Ty0>)
	1: ImmBorrowFieldGeneric[0](PurchaseCap.kiosk_id: ID)
	2: ReadRef
	3: Ret
}

public purchase_cap_item<Ty0: store + key>(Arg0: &PurchaseCap<Ty0>): ID {
B0:
	0: MoveLoc[0](Arg0: &PurchaseCap<Ty0>)
	1: ImmBorrowFieldGeneric[1](PurchaseCap.item_id: ID)
	2: ReadRef
	3: Ret
}

public purchase_cap_min_price<Ty0: store + key>(Arg0: &PurchaseCap<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &PurchaseCap<Ty0>)
	1: ImmBorrowFieldGeneric[2](PurchaseCap.min_price: u64)
	2: ReadRef
	3: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
	6 => u64: 6
	7 => u64: 7
	8 => u64: 8
	9 => u64: 9
	10 => u64: 10
	11 => u64: 11
	12 => u64: 12
]
}

// Move bytecode v6
module 2.kiosk_extension {
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::kiosk;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer_policy;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Extension has store {
	storage: Bag,
	permissions: u128,
	is_enabled: bool
}

struct ExtensionKey<phantom Ty0> has copy, drop, store {
	dummy_field: bool
}

public add<Ty0: drop>(Arg0: Ty0, Arg1: &mut Kiosk, Arg2: &KioskOwnerCap, Arg3: u128, Arg4: &mut TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut Kiosk)
	1: CopyLoc[2](Arg2: &KioskOwnerCap)
	2: Call kiosk::has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(13)
B2:
	5: MoveLoc[1](Arg1: &mut Kiosk)
	6: Pop
	7: MoveLoc[4](Arg4: &mut TxContext)
	8: Pop
	9: MoveLoc[2](Arg2: &KioskOwnerCap)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: MoveLoc[1](Arg1: &mut Kiosk)
	14: MoveLoc[2](Arg2: &KioskOwnerCap)
	15: Call kiosk::uid_mut_as_owner(&mut Kiosk, &KioskOwnerCap): &mut UID
	16: LdFalse
	17: PackGeneric[0](ExtensionKey<Ty0>)
	18: MoveLoc[4](Arg4: &mut TxContext)
	19: Call bag::new(&mut TxContext): Bag
	20: MoveLoc[3](Arg3: u128)
	21: LdTrue
	22: Pack[0](Extension)
	23: Call dynamic_field::add<ExtensionKey<Ty0>, Extension>(&mut UID, ExtensionKey<Ty0>, Extension)
	24: Ret
}

public disable<Ty0: drop>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call kiosk::has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: Call is_installed<Ty0>(&Kiosk): bool
	12: BrFalse(14)
B4:
	13: Branch(18)
B5:
	14: MoveLoc[0](Arg0: &mut Kiosk)
	15: Pop
	16: LdConst[2](u64: 3)
	17: Abort
B6:
	18: LdFalse
	19: MoveLoc[0](Arg0: &mut Kiosk)
	20: Call extension_mut<Ty0>(&mut Kiosk): &mut Extension
	21: MutBorrowField[0](Extension.is_enabled: bool)
	22: WriteRef
	23: Ret
}

public enable<Ty0: drop>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: MoveLoc[1](Arg1: &KioskOwnerCap)
	2: Call kiosk::has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: LdConst[0](u64: 0)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut Kiosk)
	10: FreezeRef
	11: Call is_installed<Ty0>(&Kiosk): bool
	12: BrFalse(14)
B4:
	13: Branch(18)
B5:
	14: MoveLoc[0](Arg0: &mut Kiosk)
	15: Pop
	16: LdConst[2](u64: 3)
	17: Abort
B6:
	18: LdTrue
	19: MoveLoc[0](Arg0: &mut Kiosk)
	20: Call extension_mut<Ty0>(&mut Kiosk): &mut Extension
	21: MutBorrowField[0](Extension.is_enabled: bool)
	22: WriteRef
	23: Ret
}

public remove<Ty0: drop>(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap) {
B0:
	0: CopyLoc[0](Arg0: &mut Kiosk)
	1: CopyLoc[1](Arg1: &KioskOwnerCap)
	2: Call kiosk::has_access(&mut Kiosk, &KioskOwnerCap): bool
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut Kiosk)
	6: Pop
	7: MoveLoc[1](Arg1: &KioskOwnerCap)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut Kiosk)
	12: FreezeRef
	13: Call is_installed<Ty0>(&Kiosk): bool
	14: BrFalse(16)
B4:
	15: Branch(22)
B5:
	16: MoveLoc[0](Arg0: &mut Kiosk)
	17: Pop
	18: MoveLoc[1](Arg1: &KioskOwnerCap)
	19: Pop
	20: LdConst[2](u64: 3)
	21: Abort
B6:
	22: MoveLoc[0](Arg0: &mut Kiosk)
	23: MoveLoc[1](Arg1: &KioskOwnerCap)
	24: Call kiosk::uid_mut_as_owner(&mut Kiosk, &KioskOwnerCap): &mut UID
	25: LdFalse
	26: PackGeneric[0](ExtensionKey<Ty0>)
	27: Call dynamic_field::remove<ExtensionKey<Ty0>, Extension>(&mut UID, ExtensionKey<Ty0>): Extension
	28: Unpack[0](Extension)
	29: Pop
	30: Pop
	31: Call bag::destroy_empty(Bag)
	32: Ret
}

public storage<Ty0: drop>(Arg0: Ty0, Arg1: &Kiosk): &Bag {
B0:
	0: CopyLoc[1](Arg1: &Kiosk)
	1: Call is_installed<Ty0>(&Kiosk): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[1](Arg1: &Kiosk)
	5: Pop
	6: LdConst[2](u64: 3)
	7: Abort
B3:
	8: MoveLoc[1](Arg1: &Kiosk)
	9: Call extension<Ty0>(&Kiosk): &Extension
	10: ImmBorrowField[1](Extension.storage: Bag)
	11: Ret
}

public storage_mut<Ty0: drop>(Arg0: Ty0, Arg1: &mut Kiosk): &mut Bag {
B0:
	0: CopyLoc[1](Arg1: &mut Kiosk)
	1: FreezeRef
	2: Call is_installed<Ty0>(&Kiosk): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut Kiosk)
	6: Pop
	7: LdConst[2](u64: 3)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: &mut Kiosk)
	10: Call extension_mut<Ty0>(&mut Kiosk): &mut Extension
	11: MutBorrowField[1](Extension.storage: Bag)
	12: Ret
}

public place<Ty0: drop, Ty1: store + key>(Arg0: Ty0, Arg1: &mut Kiosk, Arg2: Ty1, Arg3: &TransferPolicy<Ty1>) {
L4:	loc0: bool
B0:
	0: CopyLoc[1](Arg1: &mut Kiosk)
	1: FreezeRef
	2: Call is_installed<Ty0>(&Kiosk): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut Kiosk)
	6: Pop
	7: LdConst[2](u64: 3)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: &mut Kiosk)
	10: FreezeRef
	11: Call can_place<Ty0>(&Kiosk): bool
	12: BrFalse(16)
B4:
	13: LdTrue
	14: StLoc[4](loc0: bool)
	15: Branch(20)
B5:
	16: CopyLoc[1](Arg1: &mut Kiosk)
	17: FreezeRef
	18: Call can_lock<Ty0>(&Kiosk): bool
	19: StLoc[4](loc0: bool)
B6:
	20: MoveLoc[4](loc0: bool)
	21: BrFalse(23)
B7:
	22: Branch(27)
B8:
	23: MoveLoc[1](Arg1: &mut Kiosk)
	24: Pop
	25: LdConst[1](u64: 2)
	26: Abort
B9:
	27: MoveLoc[1](Arg1: &mut Kiosk)
	28: MoveLoc[2](Arg2: Ty1)
	29: Call kiosk::place_internal<Ty1>(&mut Kiosk, Ty1)
	30: Ret
}

public lock<Ty0: drop, Ty1: store + key>(Arg0: Ty0, Arg1: &mut Kiosk, Arg2: Ty1, Arg3: &TransferPolicy<Ty1>) {
B0:
	0: CopyLoc[1](Arg1: &mut Kiosk)
	1: FreezeRef
	2: Call is_installed<Ty0>(&Kiosk): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut Kiosk)
	6: Pop
	7: LdConst[2](u64: 3)
	8: Abort
B3:
	9: CopyLoc[1](Arg1: &mut Kiosk)
	10: FreezeRef
	11: Call can_lock<Ty0>(&Kiosk): bool
	12: BrFalse(14)
B4:
	13: Branch(18)
B5:
	14: MoveLoc[1](Arg1: &mut Kiosk)
	15: Pop
	16: LdConst[1](u64: 2)
	17: Abort
B6:
	18: MoveLoc[1](Arg1: &mut Kiosk)
	19: MoveLoc[2](Arg2: Ty1)
	20: Call kiosk::lock_internal<Ty1>(&mut Kiosk, Ty1)
	21: Ret
}

public is_installed<Ty0: drop>(Arg0: &Kiosk): bool {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: Call kiosk::uid(&Kiosk): &UID
	2: LdFalse
	3: PackGeneric[0](ExtensionKey<Ty0>)
	4: Call dynamic_field::exists_<ExtensionKey<Ty0>>(&UID, ExtensionKey<Ty0>): bool
	5: Ret
}

public is_enabled<Ty0: drop>(Arg0: &Kiosk): bool {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: Call extension<Ty0>(&Kiosk): &Extension
	2: ImmBorrowField[0](Extension.is_enabled: bool)
	3: ReadRef
	4: Ret
}

public can_place<Ty0: drop>(Arg0: &Kiosk): bool {
L1:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &Kiosk)
	1: Call is_enabled<Ty0>(&Kiosk): bool
	2: BrFalse(13)
B1:
	3: MoveLoc[0](Arg0: &Kiosk)
	4: Call extension<Ty0>(&Kiosk): &Extension
	5: ImmBorrowField[2](Extension.permissions: u128)
	6: ReadRef
	7: LdConst[3](u128: 1)
	8: BitAnd
	9: LdU128(0)
	10: Neq
	11: StLoc[1](loc0: bool)
	12: Branch(17)
B2:
	13: MoveLoc[0](Arg0: &Kiosk)
	14: Pop
	15: LdFalse
	16: StLoc[1](loc0: bool)
B3:
	17: MoveLoc[1](loc0: bool)
	18: Ret
}

public can_lock<Ty0: drop>(Arg0: &Kiosk): bool {
L1:	loc0: bool
B0:
	0: CopyLoc[0](Arg0: &Kiosk)
	1: Call is_enabled<Ty0>(&Kiosk): bool
	2: BrFalse(13)
B1:
	3: MoveLoc[0](Arg0: &Kiosk)
	4: Call extension<Ty0>(&Kiosk): &Extension
	5: ImmBorrowField[2](Extension.permissions: u128)
	6: ReadRef
	7: LdConst[4](u128: 2)
	8: BitAnd
	9: LdU128(0)
	10: Neq
	11: StLoc[1](loc0: bool)
	12: Branch(17)
B2:
	13: MoveLoc[0](Arg0: &Kiosk)
	14: Pop
	15: LdFalse
	16: StLoc[1](loc0: bool)
B3:
	17: MoveLoc[1](loc0: bool)
	18: Ret
}

extension<Ty0: drop>(Arg0: &Kiosk): &Extension {
B0:
	0: MoveLoc[0](Arg0: &Kiosk)
	1: Call kiosk::uid(&Kiosk): &UID
	2: LdFalse
	3: PackGeneric[0](ExtensionKey<Ty0>)
	4: Call dynamic_field::borrow<ExtensionKey<Ty0>, Extension>(&UID, ExtensionKey<Ty0>): &Extension
	5: Ret
}

extension_mut<Ty0: drop>(Arg0: &mut Kiosk): &mut Extension {
B0:
	0: MoveLoc[0](Arg0: &mut Kiosk)
	1: Call kiosk::uid_mut_internal(&mut Kiosk): &mut UID
	2: LdFalse
	3: PackGeneric[0](ExtensionKey<Ty0>)
	4: Call dynamic_field::borrow_mut<ExtensionKey<Ty0>, Extension>(&mut UID, ExtensionKey<Ty0>): &mut Extension
	5: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 2
	2 => u64: 3
	3 => u128: 1
	4 => u128: 2
]
}

// Move bytecode v6
module 2.linked_table {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct LinkedTable<Ty0: copy + drop + store, phantom Ty1: store> has store, key {
	id: UID,
	size: u64,
	head: Option<Ty0>,
	tail: Option<Ty0>
}

struct Node<Ty0: copy + drop + store, Ty1: store> has store {
	prev: Option<Ty0>,
	next: Option<Ty0>,
	value: Ty1
}

public new<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut TxContext): LinkedTable<Ty0, Ty1> {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdU64(0)
	3: Call option::none<Ty0>(): Option<Ty0>
	4: Call option::none<Ty0>(): Option<Ty0>
	5: PackGeneric[0](LinkedTable<Ty0, Ty1>)
	6: Ret
}

public front<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>): &Option<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	2: Ret
}

public back<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>): &Option<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	2: Ret
}

public push_front<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut LinkedTable<Ty0, Ty1>, Arg1: Ty0, Arg2: Ty1) {
L3:	loc0: Option<Ty0>
L4:	loc1: Option<Ty0>
L5:	loc2: Option<Ty0>
L6:	loc3: Ty0
L7:	loc4: Option<Ty0>
B0:
	0: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	2: CopyLoc[1](Arg1: Ty0)
	3: Call option::swap_or_fill<Ty0>(&mut Option<Ty0>, Ty0): Option<Ty0>
	4: StLoc[5](loc2: Option<Ty0>)
	5: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	6: ImmBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	7: Call option::is_none<Ty0>(&Option<Ty0>): bool
	8: BrFalse(13)
B1:
	9: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	10: MutBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	11: CopyLoc[1](Arg1: Ty0)
	12: Call option::fill<Ty0>(&mut Option<Ty0>, Ty0)
B2:
	13: Call option::none<Ty0>(): Option<Ty0>
	14: StLoc[7](loc4: Option<Ty0>)
	15: ImmBorrowLoc[5](loc2: Option<Ty0>)
	16: Call option::is_some<Ty0>(&Option<Ty0>): bool
	17: BrFalse(33)
B3:
	18: MoveLoc[5](loc2: Option<Ty0>)
	19: Call option::destroy_some<Ty0>(Option<Ty0>): Ty0
	20: StLoc[6](loc3: Ty0)
	21: CopyLoc[1](Arg1: Ty0)
	22: Call option::some<Ty0>(Ty0): Option<Ty0>
	23: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	24: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	25: CopyLoc[6](loc3: Ty0)
	26: Call dynamic_field::borrow_mut<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0): &mut Node<Ty0, Ty1>
	27: MutBorrowFieldGeneric[3](Node.prev: Option<Ty0>)
	28: WriteRef
	29: MoveLoc[6](loc3: Ty0)
	30: Call option::some<Ty0>(Ty0): Option<Ty0>
	31: StLoc[3](loc0: Option<Ty0>)
	32: Branch(35)
B4:
	33: Call option::none<Ty0>(): Option<Ty0>
	34: StLoc[3](loc0: Option<Ty0>)
B5:
	35: MoveLoc[3](loc0: Option<Ty0>)
	36: StLoc[4](loc1: Option<Ty0>)
	37: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	38: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	39: MoveLoc[1](Arg1: Ty0)
	40: MoveLoc[7](loc4: Option<Ty0>)
	41: MoveLoc[4](loc1: Option<Ty0>)
	42: MoveLoc[2](Arg2: Ty1)
	43: PackGeneric[1](Node<Ty0, Ty1>)
	44: Call dynamic_field::add<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0, Node<Ty0, Ty1>)
	45: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	46: ImmBorrowFieldGeneric[4](LinkedTable.size: u64)
	47: ReadRef
	48: LdU64(1)
	49: Add
	50: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	51: MutBorrowFieldGeneric[4](LinkedTable.size: u64)
	52: WriteRef
	53: Ret
}

public push_back<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut LinkedTable<Ty0, Ty1>, Arg1: Ty0, Arg2: Ty1) {
L3:	loc0: Option<Ty0>
L4:	loc1: Option<Ty0>
L5:	loc2: Option<Ty0>
L6:	loc3: Ty0
L7:	loc4: Option<Ty0>
B0:
	0: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	2: Call option::is_none<Ty0>(&Option<Ty0>): bool
	3: BrFalse(8)
B1:
	4: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	5: MutBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	6: CopyLoc[1](Arg1: Ty0)
	7: Call option::fill<Ty0>(&mut Option<Ty0>, Ty0)
B2:
	8: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	9: MutBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	10: CopyLoc[1](Arg1: Ty0)
	11: Call option::swap_or_fill<Ty0>(&mut Option<Ty0>, Ty0): Option<Ty0>
	12: StLoc[5](loc2: Option<Ty0>)
	13: ImmBorrowLoc[5](loc2: Option<Ty0>)
	14: Call option::is_some<Ty0>(&Option<Ty0>): bool
	15: BrFalse(31)
B3:
	16: MoveLoc[5](loc2: Option<Ty0>)
	17: Call option::destroy_some<Ty0>(Option<Ty0>): Ty0
	18: StLoc[6](loc3: Ty0)
	19: CopyLoc[1](Arg1: Ty0)
	20: Call option::some<Ty0>(Ty0): Option<Ty0>
	21: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	22: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	23: CopyLoc[6](loc3: Ty0)
	24: Call dynamic_field::borrow_mut<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0): &mut Node<Ty0, Ty1>
	25: MutBorrowFieldGeneric[5](Node.next: Option<Ty0>)
	26: WriteRef
	27: MoveLoc[6](loc3: Ty0)
	28: Call option::some<Ty0>(Ty0): Option<Ty0>
	29: StLoc[3](loc0: Option<Ty0>)
	30: Branch(33)
B4:
	31: Call option::none<Ty0>(): Option<Ty0>
	32: StLoc[3](loc0: Option<Ty0>)
B5:
	33: MoveLoc[3](loc0: Option<Ty0>)
	34: StLoc[7](loc4: Option<Ty0>)
	35: Call option::none<Ty0>(): Option<Ty0>
	36: StLoc[4](loc1: Option<Ty0>)
	37: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	38: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	39: MoveLoc[1](Arg1: Ty0)
	40: MoveLoc[7](loc4: Option<Ty0>)
	41: MoveLoc[4](loc1: Option<Ty0>)
	42: MoveLoc[2](Arg2: Ty1)
	43: PackGeneric[1](Node<Ty0, Ty1>)
	44: Call dynamic_field::add<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0, Node<Ty0, Ty1>)
	45: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	46: ImmBorrowFieldGeneric[4](LinkedTable.size: u64)
	47: ReadRef
	48: LdU64(1)
	49: Add
	50: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	51: MutBorrowFieldGeneric[4](LinkedTable.size: u64)
	52: WriteRef
	53: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>, Arg1: Ty0): &Ty1 {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[2](LinkedTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow<Ty0, Node<Ty0, Ty1>>(&UID, Ty0): &Node<Ty0, Ty1>
	4: ImmBorrowFieldGeneric[6](Node.value: Ty1)
	5: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut LinkedTable<Ty0, Ty1>, Arg1: Ty0): &mut Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow_mut<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0): &mut Node<Ty0, Ty1>
	4: MutBorrowFieldGeneric[6](Node.value: Ty1)
	5: Ret
}

public prev<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>, Arg1: Ty0): &Option<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[2](LinkedTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow<Ty0, Node<Ty0, Ty1>>(&UID, Ty0): &Node<Ty0, Ty1>
	4: ImmBorrowFieldGeneric[3](Node.prev: Option<Ty0>)
	5: Ret
}

public next<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>, Arg1: Ty0): &Option<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[2](LinkedTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow<Ty0, Node<Ty0, Ty1>>(&UID, Ty0): &Node<Ty0, Ty1>
	4: ImmBorrowFieldGeneric[5](Node.next: Option<Ty0>)
	5: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut LinkedTable<Ty0, Ty1>, Arg1: Ty0): Ty1 {
L2:	loc0: Option<Ty0>
L3:	loc1: Option<Ty0>
L4:	loc2: Ty1
B0:
	0: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	2: CopyLoc[1](Arg1: Ty0)
	3: Call dynamic_field::remove<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0): Node<Ty0, Ty1>
	4: UnpackGeneric[1](Node<Ty0, Ty1>)
	5: StLoc[4](loc2: Ty1)
	6: StLoc[2](loc0: Option<Ty0>)
	7: StLoc[3](loc1: Option<Ty0>)
	8: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	9: ImmBorrowFieldGeneric[4](LinkedTable.size: u64)
	10: ReadRef
	11: LdU64(1)
	12: Sub
	13: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	14: MutBorrowFieldGeneric[4](LinkedTable.size: u64)
	15: WriteRef
	16: ImmBorrowLoc[3](loc1: Option<Ty0>)
	17: Call option::is_some<Ty0>(&Option<Ty0>): bool
	18: BrFalse(28)
B1:
	19: CopyLoc[2](loc0: Option<Ty0>)
	20: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	21: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	22: ImmBorrowLoc[3](loc1: Option<Ty0>)
	23: Call option::borrow<Ty0>(&Option<Ty0>): &Ty0
	24: ReadRef
	25: Call dynamic_field::borrow_mut<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0): &mut Node<Ty0, Ty1>
	26: MutBorrowFieldGeneric[5](Node.next: Option<Ty0>)
	27: WriteRef
B2:
	28: ImmBorrowLoc[2](loc0: Option<Ty0>)
	29: Call option::is_some<Ty0>(&Option<Ty0>): bool
	30: BrFalse(40)
B3:
	31: CopyLoc[3](loc1: Option<Ty0>)
	32: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	33: MutBorrowFieldGeneric[2](LinkedTable.id: UID)
	34: ImmBorrowLoc[2](loc0: Option<Ty0>)
	35: Call option::borrow<Ty0>(&Option<Ty0>): &Ty0
	36: ReadRef
	37: Call dynamic_field::borrow_mut<Ty0, Node<Ty0, Ty1>>(&mut UID, Ty0): &mut Node<Ty0, Ty1>
	38: MutBorrowFieldGeneric[3](Node.prev: Option<Ty0>)
	39: WriteRef
B4:
	40: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	41: ImmBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	42: Call option::borrow<Ty0>(&Option<Ty0>): &Ty0
	43: ImmBorrowLoc[1](Arg1: Ty0)
	44: Eq
	45: BrFalse(50)
B5:
	46: MoveLoc[2](loc0: Option<Ty0>)
	47: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	48: MutBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	49: WriteRef
B6:
	50: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	51: ImmBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	52: Call option::borrow<Ty0>(&Option<Ty0>): &Ty0
	53: ImmBorrowLoc[1](Arg1: Ty0)
	54: Eq
	55: BrFalse(61)
B7:
	56: MoveLoc[3](loc1: Option<Ty0>)
	57: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	58: MutBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	59: WriteRef
	60: Branch(63)
B8:
	61: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	62: Pop
B9:
	63: MoveLoc[4](loc2: Ty1)
	64: Ret
}

public pop_front<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut LinkedTable<Ty0, Ty1>): Ty0 * Ty1 {
L1:	loc0: Ty0
B0:
	0: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	2: Call option::is_some<Ty0>(&Option<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	6: Pop
	7: LdConst[1](u64: 1)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	10: ImmBorrowFieldGeneric[0](LinkedTable.head: Option<Ty0>)
	11: Call option::borrow<Ty0>(&Option<Ty0>): &Ty0
	12: ReadRef
	13: StLoc[1](loc0: Ty0)
	14: CopyLoc[1](loc0: Ty0)
	15: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	16: MoveLoc[1](loc0: Ty0)
	17: Call remove<Ty0, Ty1>(&mut LinkedTable<Ty0, Ty1>, Ty0): Ty1
	18: Ret
}

public pop_back<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut LinkedTable<Ty0, Ty1>): Ty0 * Ty1 {
L1:	loc0: Ty0
B0:
	0: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	2: Call option::is_some<Ty0>(&Option<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	6: Pop
	7: LdConst[1](u64: 1)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	10: ImmBorrowFieldGeneric[1](LinkedTable.tail: Option<Ty0>)
	11: Call option::borrow<Ty0>(&Option<Ty0>): &Ty0
	12: ReadRef
	13: StLoc[1](loc0: Ty0)
	14: CopyLoc[1](loc0: Ty0)
	15: MoveLoc[0](Arg0: &mut LinkedTable<Ty0, Ty1>)
	16: MoveLoc[1](loc0: Ty0)
	17: Call remove<Ty0, Ty1>(&mut LinkedTable<Ty0, Ty1>, Ty0): Ty1
	18: Ret
}

public contains<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[2](LinkedTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::exists_with_type<Ty0, Node<Ty0, Ty1>>(&UID, Ty0): bool
	4: Ret
}

public length<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>): u64 {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[4](LinkedTable.size: u64)
	2: ReadRef
	3: Ret
}

public is_empty<Ty0: copy + drop + store, Ty1: store>(Arg0: &LinkedTable<Ty0, Ty1>): bool {
B0:
	0: MoveLoc[0](Arg0: &LinkedTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[4](LinkedTable.size: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: Ret
}

public destroy_empty<Ty0: copy + drop + store, Ty1: store>(Arg0: LinkedTable<Ty0, Ty1>) {
L1:	loc0: UID
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: LinkedTable<Ty0, Ty1>)
	1: UnpackGeneric[0](LinkedTable<Ty0, Ty1>)
	2: Pop
	3: Pop
	4: StLoc[2](loc1: u64)
	5: StLoc[1](loc0: UID)
	6: MoveLoc[2](loc1: u64)
	7: LdU64(0)
	8: Eq
	9: BrFalse(11)
B1:
	10: Branch(13)
B2:
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: MoveLoc[1](loc0: UID)
	14: Call object::delete(UID)
	15: Ret
}

public drop<Ty0: copy + drop + store, Ty1: drop + store>(Arg0: LinkedTable<Ty0, Ty1>) {
B0:
	0: MoveLoc[0](Arg0: LinkedTable<Ty0, Ty1>)
	1: UnpackGeneric[0](LinkedTable<Ty0, Ty1>)
	2: Pop
	3: Pop
	4: Pop
	5: Call object::delete(UID)
	6: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
]
}

// Move bytecode v6
module 2.math {
use 0000000000000000000000000000000000000000000000000000000000000001::u128;
use 0000000000000000000000000000000000000000000000000000000000000001::u64;

public max(Arg0: u64, Arg1: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u64)
	2: Call u64::max(u64, u64): u64
	3: Ret
}

public min(Arg0: u64, Arg1: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u64)
	2: Call u64::min(u64, u64): u64
	3: Ret
}

public diff(Arg0: u64, Arg1: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u64)
	2: Call u64::diff(u64, u64): u64
	3: Ret
}

public pow(Arg0: u64, Arg1: u8): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u8)
	2: Call u64::pow(u64, u8): u64
	3: Ret
}

public sqrt(Arg0: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: Call u64::sqrt(u64): u64
	2: Ret
}

public sqrt_u128(Arg0: u128): u128 {
B0:
	0: MoveLoc[0](Arg0: u128)
	1: Call u128::sqrt(u128): u128
	2: Ret
}

public divide_and_round_up(Arg0: u64, Arg1: u64): u64 {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: u64)
	2: Call u64::divide_and_round_up(u64, u64): u64
	3: Ret
}

}

// Move bytecode v6
module 2.nitro_attestation {
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct PCREntry has drop {
	index: u8,
	value: vector<u8>
}

struct NitroAttestationDocument has drop {
	module_id: vector<u8>,
	timestamp: u64,
	digest: vector<u8>,
	pcrs: vector<PCREntry>,
	public_key: Option<vector<u8>>,
	user_data: Option<vector<u8>>,
	nonce: Option<vector<u8>>
}

entry load_nitro_attestation(Arg0: vector<u8>, Arg1: &Clock): NitroAttestationDocument {
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u8>)
	1: MoveLoc[1](Arg1: &Clock)
	2: Call clock::timestamp_ms(&Clock): u64
	3: Call load_nitro_attestation_internal(&vector<u8>, u64): NitroAttestationDocument
	4: Ret
}

public module_id(Arg0: &NitroAttestationDocument): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[0](NitroAttestationDocument.module_id: vector<u8>)
	2: Ret
}

public timestamp(Arg0: &NitroAttestationDocument): &u64 {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[1](NitroAttestationDocument.timestamp: u64)
	2: Ret
}

public digest(Arg0: &NitroAttestationDocument): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[2](NitroAttestationDocument.digest: vector<u8>)
	2: Ret
}

public pcrs(Arg0: &NitroAttestationDocument): &vector<PCREntry> {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[3](NitroAttestationDocument.pcrs: vector<PCREntry>)
	2: Ret
}

public public_key(Arg0: &NitroAttestationDocument): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[4](NitroAttestationDocument.public_key: Option<vector<u8>>)
	2: Ret
}

public user_data(Arg0: &NitroAttestationDocument): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[5](NitroAttestationDocument.user_data: Option<vector<u8>>)
	2: Ret
}

public nonce(Arg0: &NitroAttestationDocument): &Option<vector<u8>> {
B0:
	0: MoveLoc[0](Arg0: &NitroAttestationDocument)
	1: ImmBorrowField[6](NitroAttestationDocument.nonce: Option<vector<u8>>)
	2: Ret
}

public index(Arg0: &PCREntry): u8 {
B0:
	0: MoveLoc[0](Arg0: &PCREntry)
	1: ImmBorrowField[7](PCREntry.index: u8)
	2: ReadRef
	3: Ret
}

public value(Arg0: &PCREntry): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &PCREntry)
	1: ImmBorrowField[8](PCREntry.value: vector<u8>)
	2: Ret
}

native load_nitro_attestation_internal(Arg0: &vector<u8>, Arg1: u64): NitroAttestationDocument;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
]
}

// Move bytecode v6
module 2.object {
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::bcs;

struct ID has copy, drop, store {
	bytes: address
}

struct UID has store {
	id: ID
}

public id_to_bytes(Arg0: &ID): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &ID)
	1: ImmBorrowField[0](ID.bytes: address)
	2: Call bcs::to_bytes<address>(&address): vector<u8>
	3: Ret
}

public id_to_address(Arg0: &ID): address {
B0:
	0: MoveLoc[0](Arg0: &ID)
	1: ImmBorrowField[0](ID.bytes: address)
	2: ReadRef
	3: Ret
}

public id_from_bytes(Arg0: vector<u8>): ID {
B0:
	0: MoveLoc[0](Arg0: vector<u8>)
	1: Call address::from_bytes(vector<u8>): address
	2: Call id_from_address(address): ID
	3: Ret
}

public id_from_address(Arg0: address): ID {
B0:
	0: MoveLoc[0](Arg0: address)
	1: Pack[0](ID)
	2: Ret
}

safe_system_state(Arg0: &TxContext): UID {
B0:
	0: MoveLoc[0](Arg0: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[8](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[7](u64: 0)
	7: Abort
B3:
	8: LdConst[0](address: 0x00..)
	9: Pack[0](ID)
	10: Pack[1](UID)
	11: Ret
}

public(friend) clock(): UID {
B0:
	0: LdConst[1](address: 0x00..)
	1: Pack[0](ID)
	2: Pack[1](UID)
	3: Ret
}

public(friend) authenticator_state(): UID {
B0:
	0: LdConst[2](address: 0x00..)
	1: Pack[0](ID)
	2: Pack[1](UID)
	3: Ret
}

public(friend) randomness_state(): UID {
B0:
	0: LdConst[3](address: 0x00..)
	1: Pack[0](ID)
	2: Pack[1](UID)
	3: Ret
}

public(friend) safe_deny_list_object_id(): UID {
B0:
	0: LdConst[4](address: 0x00..)
	1: Pack[0](ID)
	2: Pack[1](UID)
	3: Ret
}

public(friend) safe_accumulator_root_object_id(): UID {
B0:
	0: LdConst[5](address: 0x00..)
	1: Pack[0](ID)
	2: Pack[1](UID)
	3: Ret
}

public(friend) safe_accumulator_root_address(): address {
B0:
	0: LdConst[5](address: 0x00..)
	1: Ret
}

bridge(): UID {
B0:
	0: LdConst[6](address: 0x00..)
	1: Pack[0](ID)
	2: Pack[1](UID)
	3: Ret
}

public uid_as_inner(Arg0: &UID): &ID {
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: ImmBorrowField[1](UID.id: ID)
	2: Ret
}

public uid_to_inner(Arg0: &UID): ID {
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: ImmBorrowField[1](UID.id: ID)
	2: ReadRef
	3: Ret
}

public uid_to_bytes(Arg0: &UID): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: ImmBorrowField[1](UID.id: ID)
	2: ImmBorrowField[0](ID.bytes: address)
	3: Call bcs::to_bytes<address>(&address): vector<u8>
	4: Ret
}

public uid_to_address(Arg0: &UID): address {
B0:
	0: MoveLoc[0](Arg0: &UID)
	1: ImmBorrowField[1](UID.id: ID)
	2: ImmBorrowField[0](ID.bytes: address)
	3: ReadRef
	4: Ret
}

public new(Arg0: &mut TxContext): UID {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call tx_context::fresh_object_address(&mut TxContext): address
	2: Pack[0](ID)
	3: Pack[1](UID)
	4: Ret
}

public delete(Arg0: UID) {
B0:
	0: MoveLoc[0](Arg0: UID)
	1: Unpack[1](UID)
	2: Unpack[0](ID)
	3: Call delete_impl(address)
	4: Ret
}

public id<Ty0: key>(Arg0: &Ty0): ID {
B0:
	0: MoveLoc[0](Arg0: &Ty0)
	1: Call borrow_uid<Ty0>(&Ty0): &UID
	2: ImmBorrowField[1](UID.id: ID)
	3: ReadRef
	4: Ret
}

public borrow_id<Ty0: key>(Arg0: &Ty0): &ID {
B0:
	0: MoveLoc[0](Arg0: &Ty0)
	1: Call borrow_uid<Ty0>(&Ty0): &UID
	2: ImmBorrowField[1](UID.id: ID)
	3: Ret
}

public id_bytes<Ty0: key>(Arg0: &Ty0): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &Ty0)
	1: Call borrow_uid<Ty0>(&Ty0): &UID
	2: ImmBorrowField[1](UID.id: ID)
	3: Call bcs::to_bytes<ID>(&ID): vector<u8>
	4: Ret
}

public id_address<Ty0: key>(Arg0: &Ty0): address {
B0:
	0: MoveLoc[0](Arg0: &Ty0)
	1: Call borrow_uid<Ty0>(&Ty0): &UID
	2: ImmBorrowField[1](UID.id: ID)
	3: ImmBorrowField[0](ID.bytes: address)
	4: ReadRef
	5: Ret
}

native borrow_uid<Ty0: key>(Arg0: &Ty0): &UID;

public(friend) new_uid_from_hash(Arg0: address): UID {
B0:
	0: CopyLoc[0](Arg0: address)
	1: Call record_new_uid(address)
	2: MoveLoc[0](Arg0: address)
	3: Pack[0](ID)
	4: Pack[1](UID)
	5: Ret
}

native delete_impl(Arg0: address);

native record_new_uid(Arg0: address);

Constants [
	0 => address: 0x0000000000000000000000000000000000000000000000000000000000000005
	1 => address: 0x0000000000000000000000000000000000000000000000000000000000000006
	2 => address: 0x0000000000000000000000000000000000000000000000000000000000000007
	3 => address: 0x0000000000000000000000000000000000000000000000000000000000000008
	4 => address: 0x0000000000000000000000000000000000000000000000000000000000000403
	5 => address: 0x0000000000000000000000000000000000000000000000000000000000000acc
	6 => address: 0x0000000000000000000000000000000000000000000000000000000000000009
	7 => u64: 0
	8 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 2.object_bag {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct ObjectBag has store, key {
	id: UID,
	size: u64
}

public new(Arg0: &mut TxContext): ObjectBag {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdU64(0)
	3: Pack[0](ObjectBag)
	4: Ret
}

public add<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut ObjectBag, Arg1: Ty0, Arg2: Ty1) {
B0:
	0: CopyLoc[0](Arg0: &mut ObjectBag)
	1: MutBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: MoveLoc[2](Arg2: Ty1)
	4: Call dynamic_object_field::add<Ty0, Ty1>(&mut UID, Ty0, Ty1)
	5: CopyLoc[0](Arg0: &mut ObjectBag)
	6: ImmBorrowField[1](ObjectBag.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Add
	10: MoveLoc[0](Arg0: &mut ObjectBag)
	11: MutBorrowField[1](ObjectBag.size: u64)
	12: WriteRef
	13: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectBag, Arg1: Ty0): &Ty1 {
B0:
	0: MoveLoc[0](Arg0: &ObjectBag)
	1: ImmBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::borrow<Ty0, Ty1>(&UID, Ty0): &Ty1
	4: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut ObjectBag, Arg1: Ty0): &mut Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut ObjectBag)
	1: MutBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::borrow_mut<Ty0, Ty1>(&mut UID, Ty0): &mut Ty1
	4: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut ObjectBag, Arg1: Ty0): Ty1 {
L2:	loc0: Ty1
B0:
	0: CopyLoc[0](Arg0: &mut ObjectBag)
	1: MutBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::remove<Ty0, Ty1>(&mut UID, Ty0): Ty1
	4: StLoc[2](loc0: Ty1)
	5: CopyLoc[0](Arg0: &mut ObjectBag)
	6: ImmBorrowField[1](ObjectBag.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Sub
	10: MoveLoc[0](Arg0: &mut ObjectBag)
	11: MutBorrowField[1](ObjectBag.size: u64)
	12: WriteRef
	13: MoveLoc[2](loc0: Ty1)
	14: Ret
}

public contains<Ty0: copy + drop + store>(Arg0: &ObjectBag, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &ObjectBag)
	1: ImmBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::exists_<Ty0>(&UID, Ty0): bool
	4: Ret
}

public contains_with_type<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectBag, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &ObjectBag)
	1: ImmBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::exists_with_type<Ty0, Ty1>(&UID, Ty0): bool
	4: Ret
}

public length(Arg0: &ObjectBag): u64 {
B0:
	0: MoveLoc[0](Arg0: &ObjectBag)
	1: ImmBorrowField[1](ObjectBag.size: u64)
	2: ReadRef
	3: Ret
}

public is_empty(Arg0: &ObjectBag): bool {
B0:
	0: MoveLoc[0](Arg0: &ObjectBag)
	1: ImmBorrowField[1](ObjectBag.size: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: Ret
}

public destroy_empty(Arg0: ObjectBag) {
L1:	loc0: UID
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: ObjectBag)
	1: Unpack[0](ObjectBag)
	2: StLoc[2](loc1: u64)
	3: StLoc[1](loc0: UID)
	4: MoveLoc[2](loc1: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[1](loc0: UID)
	12: Call object::delete(UID)
	13: Ret
}

public value_id<Ty0: copy + drop + store>(Arg0: &ObjectBag, Arg1: Ty0): Option<ID> {
B0:
	0: MoveLoc[0](Arg0: &ObjectBag)
	1: ImmBorrowField[0](ObjectBag.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::id<Ty0>(&UID, Ty0): Option<ID>
	4: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.object_table {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct ObjectTable<phantom Ty0: copy + drop + store, phantom Ty1: store + key> has store, key {
	id: UID,
	size: u64
}

public new<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut TxContext): ObjectTable<Ty0, Ty1> {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdU64(0)
	3: PackGeneric[0](ObjectTable<Ty0, Ty1>)
	4: Ret
}

public add<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut ObjectTable<Ty0, Ty1>, Arg1: Ty0, Arg2: Ty1) {
B0:
	0: CopyLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](ObjectTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: MoveLoc[2](Arg2: Ty1)
	4: Call dynamic_object_field::add<Ty0, Ty1>(&mut UID, Ty0, Ty1)
	5: CopyLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	6: ImmBorrowFieldGeneric[1](ObjectTable.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Add
	10: MoveLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	11: MutBorrowFieldGeneric[1](ObjectTable.size: u64)
	12: WriteRef
	13: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectTable<Ty0, Ty1>, Arg1: Ty0): &Ty1 {
B0:
	0: MoveLoc[0](Arg0: &ObjectTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](ObjectTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::borrow<Ty0, Ty1>(&UID, Ty0): &Ty1
	4: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut ObjectTable<Ty0, Ty1>, Arg1: Ty0): &mut Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](ObjectTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::borrow_mut<Ty0, Ty1>(&mut UID, Ty0): &mut Ty1
	4: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &mut ObjectTable<Ty0, Ty1>, Arg1: Ty0): Ty1 {
L2:	loc0: Ty1
B0:
	0: CopyLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](ObjectTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::remove<Ty0, Ty1>(&mut UID, Ty0): Ty1
	4: StLoc[2](loc0: Ty1)
	5: CopyLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	6: ImmBorrowFieldGeneric[1](ObjectTable.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Sub
	10: MoveLoc[0](Arg0: &mut ObjectTable<Ty0, Ty1>)
	11: MutBorrowFieldGeneric[1](ObjectTable.size: u64)
	12: WriteRef
	13: MoveLoc[2](loc0: Ty1)
	14: Ret
}

public contains<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectTable<Ty0, Ty1>, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &ObjectTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](ObjectTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::exists_<Ty0>(&UID, Ty0): bool
	4: Ret
}

public length<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectTable<Ty0, Ty1>): u64 {
B0:
	0: MoveLoc[0](Arg0: &ObjectTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[1](ObjectTable.size: u64)
	2: ReadRef
	3: Ret
}

public is_empty<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectTable<Ty0, Ty1>): bool {
B0:
	0: MoveLoc[0](Arg0: &ObjectTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[1](ObjectTable.size: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: Ret
}

public destroy_empty<Ty0: copy + drop + store, Ty1: store + key>(Arg0: ObjectTable<Ty0, Ty1>) {
L1:	loc0: UID
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: ObjectTable<Ty0, Ty1>)
	1: UnpackGeneric[0](ObjectTable<Ty0, Ty1>)
	2: StLoc[2](loc1: u64)
	3: StLoc[1](loc0: UID)
	4: MoveLoc[2](loc1: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[1](loc0: UID)
	12: Call object::delete(UID)
	13: Ret
}

public value_id<Ty0: copy + drop + store, Ty1: store + key>(Arg0: &ObjectTable<Ty0, Ty1>, Arg1: Ty0): Option<ID> {
B0:
	0: MoveLoc[0](Arg0: &ObjectTable<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](ObjectTable.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_object_field::id<Ty0>(&UID, Ty0): Option<ID>
	4: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.package {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::types;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

struct Publisher has store, key {
	id: UID,
	package: String,
	module_name: String
}

struct UpgradeCap has store, key {
	id: UID,
	package: ID,
	version: u64,
	policy: u8
}

struct UpgradeTicket {
	cap: ID,
	package: ID,
	policy: u8,
	digest: vector<u8>
}

struct UpgradeReceipt {
	cap: ID,
	package: ID
}

public claim<Ty0: drop>(Arg0: Ty0, Arg1: &mut TxContext): Publisher {
L2:	loc0: TypeName
B0:
	0: ImmBorrowLoc[0](Arg0: Ty0)
	1: Call types::is_one_time_witness<Ty0>(&Ty0): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[1](Arg1: &mut TxContext)
	5: Pop
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: Call type_name::get_with_original_ids<Ty0>(): TypeName
	9: StLoc[2](loc0: TypeName)
	10: MoveLoc[1](Arg1: &mut TxContext)
	11: Call object::new(&mut TxContext): UID
	12: ImmBorrowLoc[2](loc0: TypeName)
	13: Call type_name::get_address(&TypeName): String
	14: ImmBorrowLoc[2](loc0: TypeName)
	15: Call type_name::get_module(&TypeName): String
	16: Pack[0](Publisher)
	17: Ret
}

public claim_and_keep<Ty0: drop>(Arg0: Ty0, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: CopyLoc[1](Arg1: &mut TxContext)
	2: Call claim<Ty0>(Ty0, &mut TxContext): Publisher
	3: MoveLoc[1](Arg1: &mut TxContext)
	4: FreezeRef
	5: Call tx_context::sender(&TxContext): address
	6: Call transfer::public_transfer<Publisher>(Publisher, address)
	7: Ret
}

public burn_publisher(Arg0: Publisher) {
B0:
	0: MoveLoc[0](Arg0: Publisher)
	1: Unpack[0](Publisher)
	2: Pop
	3: Pop
	4: Call object::delete(UID)
	5: Ret
}

public from_package<Ty0>(Arg0: &Publisher): bool {
L1:	loc0: TypeName
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: StLoc[1](loc0: TypeName)
	2: ImmBorrowLoc[1](loc0: TypeName)
	3: Call type_name::get_address(&TypeName): String
	4: MoveLoc[0](Arg0: &Publisher)
	5: ImmBorrowField[0](Publisher.package: String)
	6: ReadRef
	7: Eq
	8: Ret
}

public from_module<Ty0>(Arg0: &Publisher): bool {
L1:	loc0: bool
L2:	loc1: TypeName
B0:
	0: Call type_name::get_with_original_ids<Ty0>(): TypeName
	1: StLoc[2](loc1: TypeName)
	2: ImmBorrowLoc[2](loc1: TypeName)
	3: Call type_name::get_address(&TypeName): String
	4: CopyLoc[0](Arg0: &Publisher)
	5: ImmBorrowField[0](Publisher.package: String)
	6: ReadRef
	7: Eq
	8: BrFalse(17)
B1:
	9: ImmBorrowLoc[2](loc1: TypeName)
	10: Call type_name::get_module(&TypeName): String
	11: MoveLoc[0](Arg0: &Publisher)
	12: ImmBorrowField[1](Publisher.module_name: String)
	13: ReadRef
	14: Eq
	15: StLoc[1](loc0: bool)
	16: Branch(21)
B2:
	17: MoveLoc[0](Arg0: &Publisher)
	18: Pop
	19: LdFalse
	20: StLoc[1](loc0: bool)
B3:
	21: MoveLoc[1](loc0: bool)
	22: Ret
}

public published_module(Arg0: &Publisher): &String {
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: ImmBorrowField[1](Publisher.module_name: String)
	2: Ret
}

public published_package(Arg0: &Publisher): &String {
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: ImmBorrowField[0](Publisher.package: String)
	2: Ret
}

public upgrade_package(Arg0: &UpgradeCap): ID {
B0:
	0: MoveLoc[0](Arg0: &UpgradeCap)
	1: ImmBorrowField[2](UpgradeCap.package: ID)
	2: ReadRef
	3: Ret
}

public version(Arg0: &UpgradeCap): u64 {
B0:
	0: MoveLoc[0](Arg0: &UpgradeCap)
	1: ImmBorrowField[3](UpgradeCap.version: u64)
	2: ReadRef
	3: Ret
}

public upgrade_policy(Arg0: &UpgradeCap): u8 {
B0:
	0: MoveLoc[0](Arg0: &UpgradeCap)
	1: ImmBorrowField[4](UpgradeCap.policy: u8)
	2: ReadRef
	3: Ret
}

public ticket_package(Arg0: &UpgradeTicket): ID {
B0:
	0: MoveLoc[0](Arg0: &UpgradeTicket)
	1: ImmBorrowField[5](UpgradeTicket.package: ID)
	2: ReadRef
	3: Ret
}

public ticket_policy(Arg0: &UpgradeTicket): u8 {
B0:
	0: MoveLoc[0](Arg0: &UpgradeTicket)
	1: ImmBorrowField[6](UpgradeTicket.policy: u8)
	2: ReadRef
	3: Ret
}

public receipt_cap(Arg0: &UpgradeReceipt): ID {
B0:
	0: MoveLoc[0](Arg0: &UpgradeReceipt)
	1: ImmBorrowField[7](UpgradeReceipt.cap: ID)
	2: ReadRef
	3: Ret
}

public receipt_package(Arg0: &UpgradeReceipt): ID {
B0:
	0: MoveLoc[0](Arg0: &UpgradeReceipt)
	1: ImmBorrowField[8](UpgradeReceipt.package: ID)
	2: ReadRef
	3: Ret
}

public ticket_digest(Arg0: &UpgradeTicket): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &UpgradeTicket)
	1: ImmBorrowField[9](UpgradeTicket.digest: vector<u8>)
	2: Ret
}

public compatible_policy(): u8 {
B0:
	0: LdConst[5](u8: 0)
	1: Ret
}

public additive_policy(): u8 {
B0:
	0: LdConst[6](u8: 128)
	1: Ret
}

public dep_only_policy(): u8 {
B0:
	0: LdConst[7](u8: 192)
	1: Ret
}

entry public only_additive_upgrades(Arg0: &mut UpgradeCap) {
B0:
	0: MoveLoc[0](Arg0: &mut UpgradeCap)
	1: LdConst[6](u8: 128)
	2: Call restrict(&mut UpgradeCap, u8)
	3: Ret
}

entry public only_dep_upgrades(Arg0: &mut UpgradeCap) {
B0:
	0: MoveLoc[0](Arg0: &mut UpgradeCap)
	1: LdConst[7](u8: 192)
	2: Call restrict(&mut UpgradeCap, u8)
	3: Ret
}

entry public make_immutable(Arg0: UpgradeCap) {
B0:
	0: MoveLoc[0](Arg0: UpgradeCap)
	1: Unpack[1](UpgradeCap)
	2: Pop
	3: Pop
	4: Pop
	5: Call object::delete(UID)
	6: Ret
}

public authorize_upgrade(Arg0: &mut UpgradeCap, Arg1: u8, Arg2: vector<u8>): UpgradeTicket {
L3:	loc0: ID
L4:	loc1: ID
B0:
	0: LdConst[8](address: 0x00..)
	1: Call object::id_from_address(address): ID
	2: StLoc[3](loc0: ID)
	3: CopyLoc[0](Arg0: &mut UpgradeCap)
	4: ImmBorrowField[2](UpgradeCap.package: ID)
	5: ReadRef
	6: CopyLoc[3](loc0: ID)
	7: Neq
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[0](Arg0: &mut UpgradeCap)
	11: Pop
	12: LdConst[2](u64: 2)
	13: Abort
B3:
	14: CopyLoc[1](Arg1: u8)
	15: CopyLoc[0](Arg0: &mut UpgradeCap)
	16: ImmBorrowField[4](UpgradeCap.policy: u8)
	17: ReadRef
	18: Ge
	19: BrFalse(21)
B4:
	20: Branch(25)
B5:
	21: MoveLoc[0](Arg0: &mut UpgradeCap)
	22: Pop
	23: LdConst[1](u64: 1)
	24: Abort
B6:
	25: CopyLoc[0](Arg0: &mut UpgradeCap)
	26: ImmBorrowField[2](UpgradeCap.package: ID)
	27: ReadRef
	28: StLoc[4](loc1: ID)
	29: MoveLoc[3](loc0: ID)
	30: CopyLoc[0](Arg0: &mut UpgradeCap)
	31: MutBorrowField[2](UpgradeCap.package: ID)
	32: WriteRef
	33: MoveLoc[0](Arg0: &mut UpgradeCap)
	34: FreezeRef
	35: Call object::id<UpgradeCap>(&UpgradeCap): ID
	36: MoveLoc[4](loc1: ID)
	37: MoveLoc[1](Arg1: u8)
	38: MoveLoc[2](Arg2: vector<u8>)
	39: Pack[2](UpgradeTicket)
	40: Ret
}

public commit_upgrade(Arg0: &mut UpgradeCap, Arg1: UpgradeReceipt) {
L2:	loc0: ID
L3:	loc1: ID
B0:
	0: MoveLoc[1](Arg1: UpgradeReceipt)
	1: Unpack[3](UpgradeReceipt)
	2: StLoc[3](loc1: ID)
	3: StLoc[2](loc0: ID)
	4: CopyLoc[0](Arg0: &mut UpgradeCap)
	5: FreezeRef
	6: Call object::id<UpgradeCap>(&UpgradeCap): ID
	7: MoveLoc[2](loc0: ID)
	8: Eq
	9: BrFalse(11)
B1:
	10: Branch(15)
B2:
	11: MoveLoc[0](Arg0: &mut UpgradeCap)
	12: Pop
	13: LdConst[4](u64: 4)
	14: Abort
B3:
	15: CopyLoc[0](Arg0: &mut UpgradeCap)
	16: ImmBorrowField[2](UpgradeCap.package: ID)
	17: Call object::id_to_address(&ID): address
	18: LdConst[8](address: 0x00..)
	19: Eq
	20: BrFalse(22)
B4:
	21: Branch(26)
B5:
	22: MoveLoc[0](Arg0: &mut UpgradeCap)
	23: Pop
	24: LdConst[3](u64: 3)
	25: Abort
B6:
	26: MoveLoc[3](loc1: ID)
	27: CopyLoc[0](Arg0: &mut UpgradeCap)
	28: MutBorrowField[2](UpgradeCap.package: ID)
	29: WriteRef
	30: CopyLoc[0](Arg0: &mut UpgradeCap)
	31: ImmBorrowField[3](UpgradeCap.version: u64)
	32: ReadRef
	33: LdU64(1)
	34: Add
	35: MoveLoc[0](Arg0: &mut UpgradeCap)
	36: MutBorrowField[3](UpgradeCap.version: u64)
	37: WriteRef
	38: Ret
}

restrict(Arg0: &mut UpgradeCap, Arg1: u8) {
B0:
	0: CopyLoc[0](Arg0: &mut UpgradeCap)
	1: ImmBorrowField[4](UpgradeCap.policy: u8)
	2: ReadRef
	3: CopyLoc[1](Arg1: u8)
	4: Le
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut UpgradeCap)
	8: Pop
	9: LdConst[1](u64: 1)
	10: Abort
B3:
	11: MoveLoc[1](Arg1: u8)
	12: MoveLoc[0](Arg0: &mut UpgradeCap)
	13: MutBorrowField[4](UpgradeCap.policy: u8)
	14: WriteRef
	15: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u8: 0
	6 => u8: 128
	7 => u8: 192
	8 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}

// Move bytecode v6
module 2.party {
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct Party has copy, drop {
	default: Permissions,
	members: VecMap<address, Permissions>
}

struct Permissions has copy, drop {
	pos0: u64
}

public single_owner(Arg0: address): Party {
L1:	loc0: Party
B0:
	0: Call empty(): Party
	1: StLoc[1](loc0: Party)
	2: MutBorrowLoc[1](loc0: Party)
	3: MoveLoc[0](Arg0: address)
	4: LdConst[5](u64: 15)
	5: Pack[1](Permissions)
	6: Call set_permissions(&mut Party, address, Permissions)
	7: MoveLoc[1](loc0: Party)
	8: Ret
}

empty(): Party {
B0:
	0: LdConst[4](u64: 0)
	1: Pack[1](Permissions)
	2: Call vec_map::empty<address, Permissions>(): VecMap<address, Permissions>
	3: Pack[0](Party)
	4: Ret
}

set_permissions(Arg0: &mut Party, Arg1: address, Arg2: Permissions) {
B0:
	0: CopyLoc[0](Arg0: &mut Party)
	1: ImmBorrowField[0](Party.members: VecMap<address, Permissions>)
	2: ImmBorrowLoc[1](Arg1: address)
	3: Call vec_map::contains<address, Permissions>(&VecMap<address, Permissions>, &address): bool
	4: BrFalse(11)
B1:
	5: CopyLoc[0](Arg0: &mut Party)
	6: MutBorrowField[0](Party.members: VecMap<address, Permissions>)
	7: ImmBorrowLoc[1](Arg1: address)
	8: Call vec_map::remove<address, Permissions>(&mut VecMap<address, Permissions>, &address): address * Permissions
	9: Pop
	10: Pop
B2:
	11: MoveLoc[0](Arg0: &mut Party)
	12: MutBorrowField[0](Party.members: VecMap<address, Permissions>)
	13: MoveLoc[1](Arg1: address)
	14: MoveLoc[2](Arg2: Permissions)
	15: Call vec_map::insert<address, Permissions>(&mut VecMap<address, Permissions>, address, Permissions)
	16: Ret
}

public(friend) is_single_owner(Arg0: &Party): bool {
L1:	loc0: bool
L2:	loc1: &Permissions
B0:
	0: CopyLoc[0](Arg0: &Party)
	1: ImmBorrowField[1](Party.default: Permissions)
	2: ImmBorrowField[2](Permissions.pos0: u64)
	3: ReadRef
	4: LdConst[4](u64: 0)
	5: Eq
	6: BrFalse(31)
B1:
	7: CopyLoc[0](Arg0: &Party)
	8: ImmBorrowField[0](Party.members: VecMap<address, Permissions>)
	9: Call vec_map::size<address, Permissions>(&VecMap<address, Permissions>): u64
	10: LdU64(1)
	11: Eq
	12: BrFalse(26)
B2:
	13: MoveLoc[0](Arg0: &Party)
	14: ImmBorrowField[0](Party.members: VecMap<address, Permissions>)
	15: LdU64(0)
	16: Call vec_map::get_entry_by_idx<address, Permissions>(&VecMap<address, Permissions>, u64): &address * &Permissions
	17: StLoc[2](loc1: &Permissions)
	18: Pop
	19: MoveLoc[2](loc1: &Permissions)
	20: ImmBorrowField[2](Permissions.pos0: u64)
	21: ReadRef
	22: LdConst[5](u64: 15)
	23: Eq
	24: StLoc[1](loc0: bool)
	25: Branch(35)
B3:
	26: MoveLoc[0](Arg0: &Party)
	27: Pop
	28: LdFalse
	29: StLoc[1](loc0: bool)
	30: Branch(35)
B4:
	31: MoveLoc[0](Arg0: &Party)
	32: Pop
	33: LdFalse
	34: StLoc[1](loc0: bool)
B5:
	35: MoveLoc[1](loc0: bool)
	36: Ret
}

public(friend) into_native(Arg0: Party): u64 * vector<address> * vector<u64> {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: &mut vector<u64>
L4:	loc3: vector<address>
L5:	loc4: Permissions
L6:	loc5: Permissions
L7:	loc6: u64
L8:	loc7: VecMap<address, Permissions>
L9:	loc8: vector<Permissions>
L10:	loc9: vector<u64>
L11:	loc10: vector<u64>
L12:	loc11: u64
L13:	loc12: vector<Permissions>
L14:	loc13: vector<Permissions>
B0:
	0: MoveLoc[0](Arg0: Party)
	1: Unpack[0](Party)
	2: StLoc[8](loc7: VecMap<address, Permissions>)
	3: StLoc[5](loc4: Permissions)
	4: MoveLoc[8](loc7: VecMap<address, Permissions>)
	5: Call vec_map::into_keys_values<address, Permissions>(VecMap<address, Permissions>): vector<address> * vector<Permissions>
	6: StLoc[9](loc8: vector<Permissions>)
	7: StLoc[4](loc3: vector<address>)
	8: MoveLoc[9](loc8: vector<Permissions>)
	9: StLoc[13](loc12: vector<Permissions>)
	10: LdConst[6](vector<u64>: 00)
	11: StLoc[11](loc10: vector<u64>)
	12: MoveLoc[13](loc12: vector<Permissions>)
	13: StLoc[14](loc13: vector<Permissions>)
	14: MutBorrowLoc[14](loc13: vector<Permissions>)
	15: Call vector::reverse<Permissions>(&mut vector<Permissions>)
	16: ImmBorrowLoc[14](loc13: vector<Permissions>)
	17: VecLen(20)
	18: StLoc[1](loc0: u64)
	19: LdU64(0)
	20: StLoc[7](loc6: u64)
	21: MoveLoc[1](loc0: u64)
	22: StLoc[12](loc11: u64)
B1:
	23: CopyLoc[7](loc6: u64)
	24: CopyLoc[12](loc11: u64)
	25: Lt
	26: BrFalse(45)
B2:
	27: CopyLoc[7](loc6: u64)
	28: Pop
	29: MutBorrowLoc[14](loc13: vector<Permissions>)
	30: VecPopBack(20)
	31: StLoc[6](loc5: Permissions)
	32: MutBorrowLoc[11](loc10: vector<u64>)
	33: StLoc[3](loc2: &mut vector<u64>)
	34: MoveLoc[6](loc5: Permissions)
	35: Unpack[1](Permissions)
	36: StLoc[2](loc1: u64)
	37: MoveLoc[3](loc2: &mut vector<u64>)
	38: MoveLoc[2](loc1: u64)
	39: VecPushBack(15)
	40: MoveLoc[7](loc6: u64)
	41: LdU64(1)
	42: Add
	43: StLoc[7](loc6: u64)
	44: Branch(23)
B3:
	45: MoveLoc[14](loc13: vector<Permissions>)
	46: VecUnpack(20, 0)
	47: MoveLoc[11](loc10: vector<u64>)
	48: StLoc[10](loc9: vector<u64>)
	49: ImmBorrowLoc[5](loc4: Permissions)
	50: ImmBorrowField[2](Permissions.pos0: u64)
	51: ReadRef
	52: MoveLoc[4](loc3: vector<address>)
	53: MoveLoc[10](loc9: vector<u64>)
	54: Ret
}

Constants [
	0 => u8: 1
	1 => u8: 2
	2 => u8: 4
	3 => u8: 8
	4 => u64: 0
	5 => u64: 15
	6 => vector<u64>: 00
]
}

// Move bytecode v6
module 2.pay {
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

public keep<Ty0>(Arg0: Coin<Ty0>, Arg1: &TxContext) {
B0:
	0: MoveLoc[0](Arg0: Coin<Ty0>)
	1: MoveLoc[1](Arg1: &TxContext)
	2: Call tx_context::sender(&TxContext): address
	3: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
	4: Ret
}

entry public split<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: u64, Arg2: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	1: MoveLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: &mut TxContext)
	3: Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
	4: MoveLoc[2](Arg2: &mut TxContext)
	5: FreezeRef
	6: Call keep<Ty0>(Coin<Ty0>, &TxContext)
	7: Ret
}

entry public split_vec<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: vector<u64>, Arg2: &mut TxContext) {
L3:	loc0: u64
L4:	loc1: u64
B0:
	0: LdU64(0)
	1: ImmBorrowLoc[1](Arg1: vector<u64>)
	2: VecLen(14)
	3: StLoc[4](loc1: u64)
	4: StLoc[3](loc0: u64)
B1:
	5: CopyLoc[3](loc0: u64)
	6: CopyLoc[4](loc1: u64)
	7: Lt
	8: BrFalse(22)
B2:
	9: Branch(10)
B3:
	10: CopyLoc[0](Arg0: &mut Coin<Ty0>)
	11: ImmBorrowLoc[1](Arg1: vector<u64>)
	12: CopyLoc[3](loc0: u64)
	13: VecImmBorrow(14)
	14: ReadRef
	15: CopyLoc[2](Arg2: &mut TxContext)
	16: Call split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext)
	17: MoveLoc[3](loc0: u64)
	18: LdU64(1)
	19: Add
	20: StLoc[3](loc0: u64)
	21: Branch(5)
B4:
	22: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	23: Pop
	24: MoveLoc[2](Arg2: &mut TxContext)
	25: Pop
	26: Ret
}

entry public split_and_transfer<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: u64, Arg2: address, Arg3: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	1: MoveLoc[1](Arg1: u64)
	2: MoveLoc[3](Arg3: &mut TxContext)
	3: Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
	4: MoveLoc[2](Arg2: address)
	5: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
	6: Ret
}

entry public divide_and_keep<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: u64, Arg2: &mut TxContext) {
L3:	loc0: u64
L4:	loc1: u64
L5:	loc2: vector<Coin<Ty0>>
B0:
	0: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	1: MoveLoc[1](Arg1: u64)
	2: CopyLoc[2](Arg2: &mut TxContext)
	3: Call coin::divide_into_n<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): vector<Coin<Ty0>>
	4: StLoc[5](loc2: vector<Coin<Ty0>>)
	5: LdU64(0)
	6: ImmBorrowLoc[5](loc2: vector<Coin<Ty0>>)
	7: VecLen(10)
	8: StLoc[4](loc1: u64)
	9: StLoc[3](loc0: u64)
B1:
	10: CopyLoc[3](loc0: u64)
	11: CopyLoc[4](loc1: u64)
	12: Lt
	13: BrFalse(26)
B2:
	14: Branch(15)
B3:
	15: MutBorrowLoc[5](loc2: vector<Coin<Ty0>>)
	16: VecPopBack(10)
	17: CopyLoc[2](Arg2: &mut TxContext)
	18: FreezeRef
	19: Call tx_context::sender(&TxContext): address
	20: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
	21: MoveLoc[3](loc0: u64)
	22: LdU64(1)
	23: Add
	24: StLoc[3](loc0: u64)
	25: Branch(10)
B4:
	26: MoveLoc[2](Arg2: &mut TxContext)
	27: Pop
	28: MoveLoc[5](loc2: vector<Coin<Ty0>>)
	29: VecUnpack(10, 0)
	30: Ret
}

entry public join<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: Coin<Ty0>) {
B0:
	0: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	1: MoveLoc[1](Arg1: Coin<Ty0>)
	2: Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
	3: Ret
}

entry public join_vec<Ty0>(Arg0: &mut Coin<Ty0>, Arg1: vector<Coin<Ty0>>) {
L2:	loc0: Coin<Ty0>
L3:	loc1: u64
L4:	loc2: u64
B0:
	0: LdU64(0)
	1: ImmBorrowLoc[1](Arg1: vector<Coin<Ty0>>)
	2: VecLen(10)
	3: StLoc[4](loc2: u64)
	4: StLoc[3](loc1: u64)
B1:
	5: CopyLoc[3](loc1: u64)
	6: CopyLoc[4](loc2: u64)
	7: Lt
	8: BrFalse(21)
B2:
	9: Branch(10)
B3:
	10: MutBorrowLoc[1](Arg1: vector<Coin<Ty0>>)
	11: VecPopBack(10)
	12: StLoc[2](loc0: Coin<Ty0>)
	13: CopyLoc[0](Arg0: &mut Coin<Ty0>)
	14: MoveLoc[2](loc0: Coin<Ty0>)
	15: Call coin::join<Ty0>(&mut Coin<Ty0>, Coin<Ty0>)
	16: MoveLoc[3](loc1: u64)
	17: LdU64(1)
	18: Add
	19: StLoc[3](loc1: u64)
	20: Branch(5)
B4:
	21: MoveLoc[0](Arg0: &mut Coin<Ty0>)
	22: Pop
	23: MoveLoc[1](Arg1: vector<Coin<Ty0>>)
	24: VecUnpack(10, 0)
	25: Ret
}

entry public join_vec_and_transfer<Ty0>(Arg0: vector<Coin<Ty0>>, Arg1: address) {
L2:	loc0: Coin<Ty0>
B0:
	0: ImmBorrowLoc[0](Arg0: vector<Coin<Ty0>>)
	1: VecLen(10)
	2: LdU64(0)
	3: Gt
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[0](u64: 0)
	7: Abort
B3:
	8: MutBorrowLoc[0](Arg0: vector<Coin<Ty0>>)
	9: VecPopBack(10)
	10: StLoc[2](loc0: Coin<Ty0>)
	11: MutBorrowLoc[2](loc0: Coin<Ty0>)
	12: MoveLoc[0](Arg0: vector<Coin<Ty0>>)
	13: Call join_vec<Ty0>(&mut Coin<Ty0>, vector<Coin<Ty0>>)
	14: MoveLoc[2](loc0: Coin<Ty0>)
	15: MoveLoc[1](Arg1: address)
	16: Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
	17: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.poseidon {
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;

public poseidon_bn254(Arg0: &vector<u256>): u256 {
L1:	loc0: BCS
L2:	loc1: vector<vector<u8>>
L3:	loc2: u64
L4:	loc3: u64
B0:
	0: LdU64(0)
	1: LdConst[3](vector<vector<u8>>: 00)
	2: CopyLoc[0](Arg0: &vector<u256>)
	3: VecLen(1)
	4: StLoc[4](loc3: u64)
	5: StLoc[2](loc1: vector<vector<u8>>)
	6: StLoc[3](loc2: u64)
	7: CopyLoc[4](loc3: u64)
	8: LdU64(0)
	9: Gt
	10: BrFalse(12)
B1:
	11: Branch(16)
B2:
	12: MoveLoc[0](Arg0: &vector<u256>)
	13: Pop
	14: LdConst[1](u64: 1)
	15: Abort
B3:
	16: CopyLoc[3](loc2: u64)
	17: CopyLoc[4](loc3: u64)
	18: Lt
	19: BrFalse(43)
B4:
	20: CopyLoc[0](Arg0: &vector<u256>)
	21: CopyLoc[3](loc2: u64)
	22: VecImmBorrow(1)
	23: ReadRef
	24: LdConst[2](u256: 2188..)
	25: Lt
	26: BrFalse(28)
B5:
	27: Branch(32)
B6:
	28: MoveLoc[0](Arg0: &vector<u256>)
	29: Pop
	30: LdConst[0](u64: 0)
	31: Abort
B7:
	32: MutBorrowLoc[2](loc1: vector<vector<u8>>)
	33: CopyLoc[0](Arg0: &vector<u256>)
	34: CopyLoc[3](loc2: u64)
	35: VecImmBorrow(1)
	36: Call bcs::to_bytes<u256>(&u256): vector<u8>
	37: VecPushBack(3)
	38: MoveLoc[3](loc2: u64)
	39: LdU64(1)
	40: Add
	41: StLoc[3](loc2: u64)
	42: Branch(16)
B8:
	43: MoveLoc[0](Arg0: &vector<u256>)
	44: Pop
	45: ImmBorrowLoc[2](loc1: vector<vector<u8>>)
	46: Call poseidon_bn254_internal(&vector<vector<u8>>): vector<u8>
	47: Call bcs::new(vector<u8>): BCS
	48: StLoc[1](loc0: BCS)
	49: MutBorrowLoc[1](loc0: BCS)
	50: Call bcs::peel_u256(&mut BCS): u256
	51: Ret
}

native poseidon_bn254_internal(Arg0: &vector<vector<u8>>): vector<u8>;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u256: 21888242871839275222246405745257275088548364400416034343698204186575808495617
	3 => vector<vector<u8>>: 00
]
}

// Move bytecode v6
module 2.priority_queue {
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct PriorityQueue<Ty0: drop> has drop, store {
	entries: vector<Entry<Ty0>>
}

struct Entry<Ty0: drop> has drop, store {
	priority: u64,
	value: Ty0
}

public new<Ty0: drop>(Arg0: vector<Entry<Ty0>>): PriorityQueue<Ty0> {
L1:	loc0: u64
L2:	loc1: u64
B0:
	0: ImmBorrowLoc[0](Arg0: vector<Entry<Ty0>>)
	1: VecLen(6)
	2: StLoc[2](loc1: u64)
	3: CopyLoc[2](loc1: u64)
	4: LdU64(2)
	5: Div
	6: StLoc[1](loc0: u64)
B1:
	7: CopyLoc[1](loc0: u64)
	8: LdU64(0)
	9: Gt
	10: BrFalse(21)
B2:
	11: Branch(12)
B3:
	12: MoveLoc[1](loc0: u64)
	13: LdU64(1)
	14: Sub
	15: StLoc[1](loc0: u64)
	16: MutBorrowLoc[0](Arg0: vector<Entry<Ty0>>)
	17: CopyLoc[2](loc1: u64)
	18: CopyLoc[1](loc0: u64)
	19: Call max_heapify_recursive<Ty0>(&mut vector<Entry<Ty0>>, u64, u64)
	20: Branch(7)
B4:
	21: MoveLoc[0](Arg0: vector<Entry<Ty0>>)
	22: PackGeneric[0](PriorityQueue<Ty0>)
	23: Ret
}

public pop_max<Ty0: drop>(Arg0: &mut PriorityQueue<Ty0>): u64 * Ty0 {
L1:	loc0: u64
L2:	loc1: u64
L3:	loc2: Ty0
B0:
	0: CopyLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	1: ImmBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	2: VecLen(6)
	3: StLoc[1](loc0: u64)
	4: CopyLoc[1](loc0: u64)
	5: LdU64(0)
	6: Gt
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: CopyLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	14: MutBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	15: LdU64(0)
	16: Call vector::swap_remove<Entry<Ty0>>(&mut vector<Entry<Ty0>>, u64): Entry<Ty0>
	17: UnpackGeneric[1](Entry<Ty0>)
	18: StLoc[3](loc2: Ty0)
	19: StLoc[2](loc1: u64)
	20: MoveLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	21: MutBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	22: MoveLoc[1](loc0: u64)
	23: LdU64(1)
	24: Sub
	25: LdU64(0)
	26: Call max_heapify_recursive<Ty0>(&mut vector<Entry<Ty0>>, u64, u64)
	27: MoveLoc[2](loc1: u64)
	28: MoveLoc[3](loc2: Ty0)
	29: Ret
}

public insert<Ty0: drop>(Arg0: &mut PriorityQueue<Ty0>, Arg1: u64, Arg2: Ty0) {
L3:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	1: MutBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	2: MoveLoc[1](Arg1: u64)
	3: MoveLoc[2](Arg2: Ty0)
	4: PackGeneric[1](Entry<Ty0>)
	5: VecPushBack(6)
	6: CopyLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	7: ImmBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	8: VecLen(6)
	9: LdU64(1)
	10: Sub
	11: StLoc[3](loc0: u64)
	12: MoveLoc[0](Arg0: &mut PriorityQueue<Ty0>)
	13: MutBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	14: MoveLoc[3](loc0: u64)
	15: Call restore_heap_recursive<Ty0>(&mut vector<Entry<Ty0>>, u64)
	16: Ret
}

public new_entry<Ty0: drop>(Arg0: u64, Arg1: Ty0): Entry<Ty0> {
B0:
	0: MoveLoc[0](Arg0: u64)
	1: MoveLoc[1](Arg1: Ty0)
	2: PackGeneric[1](Entry<Ty0>)
	3: Ret
}

public create_entries<Ty0: drop>(Arg0: vector<u64>, Arg1: vector<Ty0>): vector<Entry<Ty0>> {
L2:	loc0: u64
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: vector<Entry<Ty0>>
L6:	loc4: Ty0
B0:
	0: ImmBorrowLoc[0](Arg0: vector<u64>)
	1: VecLen(16)
	2: StLoc[3](loc1: u64)
	3: ImmBorrowLoc[1](Arg1: vector<Ty0>)
	4: VecLen(13)
	5: CopyLoc[3](loc1: u64)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdU64(0)
	10: Abort
B3:
	11: VecPack(6, 0)
	12: StLoc[5](loc3: vector<Entry<Ty0>>)
	13: LdU64(0)
	14: StLoc[2](loc0: u64)
B4:
	15: CopyLoc[2](loc0: u64)
	16: CopyLoc[3](loc1: u64)
	17: Lt
	18: BrFalse(37)
B5:
	19: MutBorrowLoc[0](Arg0: vector<u64>)
	20: LdU64(0)
	21: Call vector::remove<u64>(&mut vector<u64>, u64): u64
	22: StLoc[4](loc2: u64)
	23: MutBorrowLoc[1](Arg1: vector<Ty0>)
	24: LdU64(0)
	25: Call vector::remove<Ty0>(&mut vector<Ty0>, u64): Ty0
	26: StLoc[6](loc4: Ty0)
	27: MutBorrowLoc[5](loc3: vector<Entry<Ty0>>)
	28: MoveLoc[4](loc2: u64)
	29: MoveLoc[6](loc4: Ty0)
	30: PackGeneric[1](Entry<Ty0>)
	31: VecPushBack(6)
	32: MoveLoc[2](loc0: u64)
	33: LdU64(1)
	34: Add
	35: StLoc[2](loc0: u64)
	36: Branch(15)
B6:
	37: MoveLoc[5](loc3: vector<Entry<Ty0>>)
	38: Ret
}

restore_heap_recursive<Ty0: drop>(Arg0: &mut vector<Entry<Ty0>>, Arg1: u64) {
L2:	loc0: u64
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdU64(0)
	2: Eq
	3: BrFalse(7)
B1:
	4: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	5: Pop
	6: Ret
B2:
	7: CopyLoc[1](Arg1: u64)
	8: LdU64(1)
	9: Sub
	10: LdU64(2)
	11: Div
	12: StLoc[2](loc0: u64)
	13: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	14: FreezeRef
	15: CopyLoc[1](Arg1: u64)
	16: VecImmBorrow(6)
	17: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	18: ReadRef
	19: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	20: FreezeRef
	21: CopyLoc[2](loc0: u64)
	22: VecImmBorrow(6)
	23: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	24: ReadRef
	25: Gt
	26: BrFalse(35)
B3:
	27: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	28: MoveLoc[1](Arg1: u64)
	29: CopyLoc[2](loc0: u64)
	30: VecSwap(6)
	31: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	32: MoveLoc[2](loc0: u64)
	33: Call restore_heap_recursive<Ty0>(&mut vector<Entry<Ty0>>, u64)
	34: Branch(37)
B4:
	35: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	36: Pop
B5:
	37: Ret
}

max_heapify_recursive<Ty0: drop>(Arg0: &mut vector<Entry<Ty0>>, Arg1: u64, Arg2: u64) {
L3:	loc0: bool
L4:	loc1: bool
L5:	loc2: u64
L6:	loc3: u64
L7:	loc4: u64
B0:
	0: CopyLoc[1](Arg1: u64)
	1: LdU64(0)
	2: Eq
	3: BrFalse(7)
B1:
	4: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	5: Pop
	6: Ret
B2:
	7: CopyLoc[2](Arg2: u64)
	8: CopyLoc[1](Arg1: u64)
	9: Lt
	10: BrFalse(12)
B3:
	11: Branch(16)
B4:
	12: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	13: Pop
	14: LdU64(1)
	15: Abort
B5:
	16: CopyLoc[2](Arg2: u64)
	17: LdU64(2)
	18: Mul
	19: LdU64(1)
	20: Add
	21: StLoc[5](loc2: u64)
	22: CopyLoc[5](loc2: u64)
	23: LdU64(1)
	24: Add
	25: StLoc[7](loc4: u64)
	26: CopyLoc[2](Arg2: u64)
	27: StLoc[6](loc3: u64)
	28: CopyLoc[5](loc2: u64)
	29: CopyLoc[1](Arg1: u64)
	30: Lt
	31: BrFalse(47)
B6:
	32: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	33: FreezeRef
	34: CopyLoc[5](loc2: u64)
	35: VecImmBorrow(6)
	36: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	37: ReadRef
	38: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	39: FreezeRef
	40: CopyLoc[6](loc3: u64)
	41: VecImmBorrow(6)
	42: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	43: ReadRef
	44: Gt
	45: StLoc[3](loc0: bool)
	46: Branch(49)
B7:
	47: LdFalse
	48: StLoc[3](loc0: bool)
B8:
	49: MoveLoc[3](loc0: bool)
	50: BrFalse(53)
B9:
	51: MoveLoc[5](loc2: u64)
	52: StLoc[6](loc3: u64)
B10:
	53: CopyLoc[7](loc4: u64)
	54: CopyLoc[1](Arg1: u64)
	55: Lt
	56: BrFalse(72)
B11:
	57: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	58: FreezeRef
	59: CopyLoc[7](loc4: u64)
	60: VecImmBorrow(6)
	61: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	62: ReadRef
	63: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	64: FreezeRef
	65: CopyLoc[6](loc3: u64)
	66: VecImmBorrow(6)
	67: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	68: ReadRef
	69: Gt
	70: StLoc[4](loc1: bool)
	71: Branch(74)
B12:
	72: LdFalse
	73: StLoc[4](loc1: bool)
B13:
	74: MoveLoc[4](loc1: bool)
	75: BrFalse(78)
B14:
	76: MoveLoc[7](loc4: u64)
	77: StLoc[6](loc3: u64)
B15:
	78: CopyLoc[6](loc3: u64)
	79: CopyLoc[2](Arg2: u64)
	80: Neq
	81: BrFalse(91)
B16:
	82: CopyLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	83: CopyLoc[6](loc3: u64)
	84: MoveLoc[2](Arg2: u64)
	85: VecSwap(6)
	86: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	87: MoveLoc[1](Arg1: u64)
	88: MoveLoc[6](loc3: u64)
	89: Call max_heapify_recursive<Ty0>(&mut vector<Entry<Ty0>>, u64, u64)
	90: Branch(93)
B17:
	91: MoveLoc[0](Arg0: &mut vector<Entry<Ty0>>)
	92: Pop
B18:
	93: Ret
}

public priorities<Ty0: drop>(Arg0: &PriorityQueue<Ty0>): vector<u64> {
L1:	loc0: u64
L2:	loc1: vector<u64>
B0:
	0: LdConst[1](vector<u64>: 00)
	1: StLoc[2](loc1: vector<u64>)
	2: LdU64(0)
	3: StLoc[1](loc0: u64)
B1:
	4: CopyLoc[1](loc0: u64)
	5: CopyLoc[0](Arg0: &PriorityQueue<Ty0>)
	6: ImmBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	7: VecLen(6)
	8: Lt
	9: BrFalse(24)
B2:
	10: Branch(11)
B3:
	11: MutBorrowLoc[2](loc1: vector<u64>)
	12: CopyLoc[0](Arg0: &PriorityQueue<Ty0>)
	13: ImmBorrowFieldGeneric[0](PriorityQueue.entries: vector<Entry<Ty0>>)
	14: CopyLoc[1](loc0: u64)
	15: VecImmBorrow(6)
	16: ImmBorrowFieldGeneric[1](Entry.priority: u64)
	17: ReadRef
	18: VecPushBack(16)
	19: MoveLoc[1](loc0: u64)
	20: LdU64(1)
	21: Add
	22: StLoc[1](loc0: u64)
	23: Branch(4)
B4:
	24: MoveLoc[0](Arg0: &PriorityQueue<Ty0>)
	25: Pop
	26: MoveLoc[2](loc1: vector<u64>)
	27: Ret
}

Constants [
	0 => u64: 0
	1 => vector<u64>: 00
]
}

// Move bytecode v6
module 2.prover {

}

// Move bytecode v6
module 2.random {
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000002::hmac;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::versioned;
use 0000000000000000000000000000000000000000000000000000000000000001::bcs;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct Random has key {
	id: UID,
	inner: Versioned
}

struct RandomInner has store {
	version: u64,
	epoch: u64,
	randomness_round: u64,
	random_bytes: vector<u8>
}

struct RandomGenerator has drop {
	seed: vector<u8>,
	counter: u16,
	buffer: vector<u8>
}

create(Arg0: &mut TxContext) {
L1:	loc0: RandomInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: LdConst[7](address: 0x00..)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut TxContext)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: LdConst[1](u64: 1)
	12: StLoc[2](loc1: u64)
	13: CopyLoc[2](loc1: u64)
	14: CopyLoc[0](Arg0: &mut TxContext)
	15: FreezeRef
	16: Call tx_context::epoch(&TxContext): u64
	17: LdU64(0)
	18: LdConst[8](vector<u8>: "" /..)
	19: Pack[1](RandomInner)
	20: StLoc[1](loc0: RandomInner)
	21: Call object::randomness_state(): UID
	22: MoveLoc[2](loc1: u64)
	23: MoveLoc[1](loc0: RandomInner)
	24: MoveLoc[0](Arg0: &mut TxContext)
	25: Call versioned::create<RandomInner>(u64, RandomInner, &mut TxContext): Versioned
	26: Pack[0](Random)
	27: Call transfer::share_object<Random>(Random)
	28: Ret
}

load_inner_mut(Arg0: &mut Random): &mut RandomInner {
L1:	loc0: &mut RandomInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &mut Random)
	1: ImmBorrowField[0](Random.inner: Versioned)
	2: Call versioned::version(&Versioned): u64
	3: StLoc[2](loc1: u64)
	4: CopyLoc[2](loc1: u64)
	5: LdConst[1](u64: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut Random)
	10: Pop
	11: LdConst[1](u64: 1)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut Random)
	14: MutBorrowField[0](Random.inner: Versioned)
	15: Call versioned::load_value_mut<RandomInner>(&mut Versioned): &mut RandomInner
	16: StLoc[1](loc0: &mut RandomInner)
	17: CopyLoc[1](loc0: &mut RandomInner)
	18: ImmBorrowField[1](RandomInner.version: u64)
	19: ReadRef
	20: MoveLoc[2](loc1: u64)
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[1](loc0: &mut RandomInner)
	25: Pop
	26: LdConst[1](u64: 1)
	27: Abort
B6:
	28: MoveLoc[1](loc0: &mut RandomInner)
	29: Ret
}

load_inner(Arg0: &Random): &RandomInner {
L1:	loc0: &RandomInner
L2:	loc1: u64
B0:
	0: CopyLoc[0](Arg0: &Random)
	1: ImmBorrowField[0](Random.inner: Versioned)
	2: Call versioned::version(&Versioned): u64
	3: StLoc[2](loc1: u64)
	4: CopyLoc[2](loc1: u64)
	5: LdConst[1](u64: 1)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &Random)
	10: Pop
	11: LdConst[1](u64: 1)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &Random)
	14: ImmBorrowField[0](Random.inner: Versioned)
	15: Call versioned::load_value<RandomInner>(&Versioned): &RandomInner
	16: StLoc[1](loc0: &RandomInner)
	17: CopyLoc[1](loc0: &RandomInner)
	18: ImmBorrowField[1](RandomInner.version: u64)
	19: ReadRef
	20: MoveLoc[2](loc1: u64)
	21: Eq
	22: BrFalse(24)
B4:
	23: Branch(28)
B5:
	24: MoveLoc[1](loc0: &RandomInner)
	25: Pop
	26: LdConst[1](u64: 1)
	27: Abort
B6:
	28: MoveLoc[1](loc0: &RandomInner)
	29: Ret
}

update_randomness_state(Arg0: &mut Random, Arg1: u64, Arg2: vector<u8>, Arg3: &TxContext) {
L4:	loc0: bool
L5:	loc1: bool
L6:	loc2: bool
L7:	loc3: u64
L8:	loc4: &mut RandomInner
B0:
	0: CopyLoc[3](Arg3: &TxContext)
	1: Call tx_context::sender(&TxContext): address
	2: LdConst[7](address: 0x00..)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(12)
B2:
	6: MoveLoc[0](Arg0: &mut Random)
	7: Pop
	8: MoveLoc[3](Arg3: &TxContext)
	9: Pop
	10: LdConst[0](u64: 0)
	11: Abort
B3:
	12: CopyLoc[3](Arg3: &TxContext)
	13: Call tx_context::epoch(&TxContext): u64
	14: StLoc[7](loc3: u64)
	15: MoveLoc[0](Arg0: &mut Random)
	16: Call load_inner_mut(&mut Random): &mut RandomInner
	17: StLoc[8](loc4: &mut RandomInner)
	18: CopyLoc[8](loc4: &mut RandomInner)
	19: ImmBorrowField[2](RandomInner.randomness_round: u64)
	20: ReadRef
	21: LdU64(0)
	22: Eq
	23: BrFalse(38)
B4:
	24: CopyLoc[8](loc4: &mut RandomInner)
	25: ImmBorrowField[3](RandomInner.epoch: u64)
	26: ReadRef
	27: LdU64(0)
	28: Eq
	29: BrFalse(35)
B5:
	30: CopyLoc[8](loc4: &mut RandomInner)
	31: ImmBorrowField[4](RandomInner.random_bytes: vector<u8>)
	32: Call vector::is_empty<u8>(&vector<u8>): bool
	33: StLoc[4](loc0: bool)
	34: Branch(40)
B6:
	35: LdFalse
	36: StLoc[4](loc0: bool)
	37: Branch(40)
B7:
	38: LdFalse
	39: StLoc[4](loc0: bool)
B8:
	40: MoveLoc[4](loc0: bool)
	41: BrFalse(53)
B9:
	42: CopyLoc[1](Arg1: u64)
	43: LdU64(0)
	44: Eq
	45: BrFalse(47)
B10:
	46: Branch(88)
B11:
	47: MoveLoc[8](loc4: &mut RandomInner)
	48: Pop
	49: MoveLoc[3](Arg3: &TxContext)
	50: Pop
	51: LdConst[2](u64: 2)
	52: Abort
B12:
	53: MoveLoc[7](loc3: u64)
	54: CopyLoc[8](loc4: &mut RandomInner)
	55: ImmBorrowField[3](RandomInner.epoch: u64)
	56: ReadRef
	57: Gt
	58: BrFalse(64)
B13:
	59: CopyLoc[1](Arg1: u64)
	60: LdU64(0)
	61: Eq
	62: StLoc[6](loc2: bool)
	63: Branch(66)
B14:
	64: LdFalse
	65: StLoc[6](loc2: bool)
B15:
	66: MoveLoc[6](loc2: bool)
	67: BrFalse(71)
B16:
	68: LdTrue
	69: StLoc[5](loc1: bool)
	70: Branch(79)
B17:
	71: CopyLoc[1](Arg1: u64)
	72: CopyLoc[8](loc4: &mut RandomInner)
	73: ImmBorrowField[2](RandomInner.randomness_round: u64)
	74: ReadRef
	75: LdU64(1)
	76: Add
	77: Eq
	78: StLoc[5](loc1: bool)
B18:
	79: MoveLoc[5](loc1: bool)
	80: BrFalse(82)
B19:
	81: Branch(88)
B20:
	82: MoveLoc[8](loc4: &mut RandomInner)
	83: Pop
	84: MoveLoc[3](Arg3: &TxContext)
	85: Pop
	86: LdConst[2](u64: 2)
	87: Abort
B21:
	88: MoveLoc[3](Arg3: &TxContext)
	89: Call tx_context::epoch(&TxContext): u64
	90: CopyLoc[8](loc4: &mut RandomInner)
	91: MutBorrowField[3](RandomInner.epoch: u64)
	92: WriteRef
	93: MoveLoc[1](Arg1: u64)
	94: CopyLoc[8](loc4: &mut RandomInner)
	95: MutBorrowField[2](RandomInner.randomness_round: u64)
	96: WriteRef
	97: MoveLoc[2](Arg2: vector<u8>)
	98: MoveLoc[8](loc4: &mut RandomInner)
	99: MutBorrowField[4](RandomInner.random_bytes: vector<u8>)
	100: WriteRef
	101: Ret
}

public new_generator(Arg0: &Random, Arg1: &mut TxContext): RandomGenerator {
L2:	loc0: vector<u8>
L3:	loc1: &vector<u8>
B0:
	0: MoveLoc[0](Arg0: &Random)
	1: Call load_inner(&Random): &RandomInner
	2: ImmBorrowField[4](RandomInner.random_bytes: vector<u8>)
	3: StLoc[3](loc1: &vector<u8>)
	4: MoveLoc[1](Arg1: &mut TxContext)
	5: Call tx_context::fresh_object_address(&mut TxContext): address
	6: Call address::to_bytes(address): vector<u8>
	7: StLoc[2](loc0: vector<u8>)
	8: MoveLoc[3](loc1: &vector<u8>)
	9: ImmBorrowLoc[2](loc0: vector<u8>)
	10: Call hmac::hmac_sha3_256(&vector<u8>, &vector<u8>): vector<u8>
	11: LdU16(0)
	12: LdConst[8](vector<u8>: "" /..)
	13: Pack[2](RandomGenerator)
	14: Ret
}

derive_next_block(Arg0: &mut RandomGenerator): vector<u8> {
L1:	loc0: vector<u8>
L2:	loc1: &vector<u8>
B0:
	0: CopyLoc[0](Arg0: &mut RandomGenerator)
	1: ImmBorrowField[5](RandomGenerator.counter: u16)
	2: ReadRef
	3: LdU16(1)
	4: Add
	5: CopyLoc[0](Arg0: &mut RandomGenerator)
	6: MutBorrowField[5](RandomGenerator.counter: u16)
	7: WriteRef
	8: CopyLoc[0](Arg0: &mut RandomGenerator)
	9: ImmBorrowField[6](RandomGenerator.seed: vector<u8>)
	10: StLoc[2](loc1: &vector<u8>)
	11: MoveLoc[0](Arg0: &mut RandomGenerator)
	12: ImmBorrowField[5](RandomGenerator.counter: u16)
	13: Call bcs::to_bytes<u16>(&u16): vector<u8>
	14: StLoc[1](loc0: vector<u8>)
	15: MoveLoc[2](loc1: &vector<u8>)
	16: ImmBorrowLoc[1](loc0: vector<u8>)
	17: Call hmac::hmac_sha3_256(&vector<u8>, &vector<u8>): vector<u8>
	18: Ret
}

public generate_bytes(Arg0: &mut RandomGenerator, Arg1: u16): vector<u8> {
L2:	loc0: u16
L3:	loc1: u64
L4:	loc2: u64
L5:	loc3: u16
L6:	loc4: vector<u8>
L7:	loc5: u64
L8:	loc6: vector<u8>
L9:	loc7: u64
L10:	loc8: u16
B0:
	0: LdConst[8](vector<u8>: "" /..)
	1: StLoc[8](loc6: vector<u8>)
	2: CopyLoc[1](Arg1: u16)
	3: LdConst[5](u16: 32)
	4: Div
	5: StLoc[2](loc0: u16)
	6: LdU16(0)
	7: StLoc[5](loc3: u16)
	8: MoveLoc[2](loc0: u16)
	9: StLoc[10](loc8: u16)
B1:
	10: CopyLoc[5](loc3: u16)
	11: CopyLoc[10](loc8: u16)
	12: Lt
	13: BrFalse(25)
B2:
	14: CopyLoc[5](loc3: u16)
	15: Pop
	16: MutBorrowLoc[8](loc6: vector<u8>)
	17: CopyLoc[0](Arg0: &mut RandomGenerator)
	18: Call derive_next_block(&mut RandomGenerator): vector<u8>
	19: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	20: MoveLoc[5](loc3: u16)
	21: LdU16(1)
	22: Add
	23: StLoc[5](loc3: u16)
	24: Branch(10)
B3:
	25: MoveLoc[1](Arg1: u16)
	26: CastU64
	27: ImmBorrowLoc[8](loc6: vector<u8>)
	28: VecLen(17)
	29: Sub
	30: StLoc[7](loc5: u64)
	31: CopyLoc[0](Arg0: &mut RandomGenerator)
	32: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	33: VecLen(17)
	34: CopyLoc[7](loc5: u64)
	35: Lt
	36: BrFalse(45)
B4:
	37: CopyLoc[0](Arg0: &mut RandomGenerator)
	38: Call derive_next_block(&mut RandomGenerator): vector<u8>
	39: StLoc[6](loc4: vector<u8>)
	40: CopyLoc[0](Arg0: &mut RandomGenerator)
	41: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	42: MoveLoc[6](loc4: vector<u8>)
	43: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
	44: Branch(45)
B5:
	45: MoveLoc[7](loc5: u64)
	46: StLoc[3](loc1: u64)
	47: LdU64(0)
	48: StLoc[4](loc2: u64)
	49: MoveLoc[3](loc1: u64)
	50: StLoc[9](loc7: u64)
B6:
	51: CopyLoc[4](loc2: u64)
	52: CopyLoc[9](loc7: u64)
	53: Lt
	54: BrFalse(67)
B7:
	55: CopyLoc[4](loc2: u64)
	56: Pop
	57: MutBorrowLoc[8](loc6: vector<u8>)
	58: CopyLoc[0](Arg0: &mut RandomGenerator)
	59: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	60: VecPopBack(17)
	61: VecPushBack(17)
	62: MoveLoc[4](loc2: u64)
	63: LdU64(1)
	64: Add
	65: StLoc[4](loc2: u64)
	66: Branch(51)
B8:
	67: MoveLoc[0](Arg0: &mut RandomGenerator)
	68: Pop
	69: MoveLoc[8](loc6: vector<u8>)
	70: Ret
}

public generate_u256(Arg0: &mut RandomGenerator): u256 {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(32)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU256
	52: Ret
}

public generate_u128(Arg0: &mut RandomGenerator): u128 {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(16)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU128
	52: Ret
}

public generate_u64(Arg0: &mut RandomGenerator): u64 {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(8)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU64
	52: Ret
}

public generate_u32(Arg0: &mut RandomGenerator): u32 {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(4)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU32
	52: Ret
}

public generate_u16(Arg0: &mut RandomGenerator): u16 {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(2)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU16
	52: Ret
}

public generate_u8(Arg0: &mut RandomGenerator): u8 {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(1)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU8
	52: Ret
}

public generate_bool(Arg0: &mut RandomGenerator): bool {
L1:	loc0: u8
L2:	loc1: u256
L3:	loc2: &mut RandomGenerator
L4:	loc3: u8
L5:	loc4: vector<u8>
L6:	loc5: u8
L7:	loc6: u256
L8:	loc7: u8
B0:
	0: MoveLoc[0](Arg0: &mut RandomGenerator)
	1: StLoc[3](loc2: &mut RandomGenerator)
	2: LdU8(1)
	3: StLoc[6](loc5: u8)
	4: CopyLoc[3](loc2: &mut RandomGenerator)
	5: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	6: VecLen(17)
	7: CopyLoc[6](loc5: u8)
	8: CastU64
	9: Lt
	10: BrFalse(18)
B1:
	11: CopyLoc[3](loc2: &mut RandomGenerator)
	12: Call derive_next_block(&mut RandomGenerator): vector<u8>
	13: StLoc[5](loc4: vector<u8>)
	14: CopyLoc[3](loc2: &mut RandomGenerator)
	15: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	16: MoveLoc[5](loc4: vector<u8>)
	17: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B2:
	18: LdU256(0)
	19: StLoc[7](loc6: u256)
	20: MoveLoc[6](loc5: u8)
	21: StLoc[1](loc0: u8)
	22: LdU8(0)
	23: StLoc[4](loc3: u8)
	24: MoveLoc[1](loc0: u8)
	25: StLoc[8](loc7: u8)
B3:
	26: CopyLoc[4](loc3: u8)
	27: CopyLoc[8](loc7: u8)
	28: Lt
	29: BrFalse(48)
B4:
	30: CopyLoc[4](loc3: u8)
	31: Pop
	32: CopyLoc[3](loc2: &mut RandomGenerator)
	33: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	34: VecPopBack(17)
	35: CastU256
	36: StLoc[2](loc1: u256)
	37: MoveLoc[7](loc6: u256)
	38: LdU8(8)
	39: Shl
	40: MoveLoc[2](loc1: u256)
	41: Add
	42: StLoc[7](loc6: u256)
	43: MoveLoc[4](loc3: u8)
	44: LdU8(1)
	45: Add
	46: StLoc[4](loc3: u8)
	47: Branch(26)
B5:
	48: MoveLoc[3](loc2: &mut RandomGenerator)
	49: Pop
	50: MoveLoc[7](loc6: u256)
	51: CastU64
	52: LdU64(1)
	53: BitAnd
	54: LdU64(1)
	55: Eq
	56: Ret
}

public generate_u128_in_range(Arg0: &mut RandomGenerator, Arg1: u128, Arg2: u128): u128 {
L3:	loc0: u8
L4:	loc1: u128
L5:	loc2: u256
L6:	loc3: &mut RandomGenerator
L7:	loc4: u8
L8:	loc5: u128
L9:	loc6: u128
L10:	loc7: vector<u8>
L11:	loc8: u8
L12:	loc9: u256
L13:	loc10: u256
L14:	loc11: u256
L15:	loc12: u8
B0:
	0: MoveLoc[1](Arg1: u128)
	1: StLoc[9](loc6: u128)
	2: MoveLoc[2](Arg2: u128)
	3: StLoc[8](loc5: u128)
	4: CopyLoc[9](loc6: u128)
	5: CopyLoc[8](loc5: u128)
	6: Le
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut RandomGenerator)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: CopyLoc[9](loc6: u128)
	14: CopyLoc[8](loc5: u128)
	15: Eq
	16: BrFalse(22)
B4:
	17: MoveLoc[0](Arg0: &mut RandomGenerator)
	18: Pop
	19: MoveLoc[9](loc6: u128)
	20: StLoc[4](loc1: u128)
	21: Branch(89)
B5:
	22: MoveLoc[8](loc5: u128)
	23: CopyLoc[9](loc6: u128)
	24: Sub
	25: CastU256
	26: LdU256(1)
	27: Add
	28: StLoc[13](loc10: u256)
	29: MoveLoc[0](Arg0: &mut RandomGenerator)
	30: StLoc[6](loc3: &mut RandomGenerator)
	31: LdU8(24)
	32: StLoc[11](loc8: u8)
	33: CopyLoc[6](loc3: &mut RandomGenerator)
	34: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	35: VecLen(17)
	36: CopyLoc[11](loc8: u8)
	37: CastU64
	38: Lt
	39: BrFalse(47)
B6:
	40: CopyLoc[6](loc3: &mut RandomGenerator)
	41: Call derive_next_block(&mut RandomGenerator): vector<u8>
	42: StLoc[10](loc7: vector<u8>)
	43: CopyLoc[6](loc3: &mut RandomGenerator)
	44: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	45: MoveLoc[10](loc7: vector<u8>)
	46: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B7:
	47: LdU256(0)
	48: StLoc[14](loc11: u256)
	49: MoveLoc[11](loc8: u8)
	50: StLoc[3](loc0: u8)
	51: LdU8(0)
	52: StLoc[7](loc4: u8)
	53: MoveLoc[3](loc0: u8)
	54: StLoc[15](loc12: u8)
B8:
	55: CopyLoc[7](loc4: u8)
	56: CopyLoc[15](loc12: u8)
	57: Lt
	58: BrFalse(77)
B9:
	59: CopyLoc[7](loc4: u8)
	60: Pop
	61: CopyLoc[6](loc3: &mut RandomGenerator)
	62: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	63: VecPopBack(17)
	64: CastU256
	65: StLoc[5](loc2: u256)
	66: MoveLoc[14](loc11: u256)
	67: LdU8(8)
	68: Shl
	69: MoveLoc[5](loc2: u256)
	70: Add
	71: StLoc[14](loc11: u256)
	72: MoveLoc[7](loc4: u8)
	73: LdU8(1)
	74: Add
	75: StLoc[7](loc4: u8)
	76: Branch(55)
B10:
	77: MoveLoc[6](loc3: &mut RandomGenerator)
	78: Pop
	79: MoveLoc[14](loc11: u256)
	80: CastU256
	81: StLoc[12](loc9: u256)
	82: MoveLoc[9](loc6: u128)
	83: MoveLoc[12](loc9: u256)
	84: MoveLoc[13](loc10: u256)
	85: Mod
	86: CastU128
	87: Add
	88: StLoc[4](loc1: u128)
B11:
	89: MoveLoc[4](loc1: u128)
	90: Ret
}

public generate_u64_in_range(Arg0: &mut RandomGenerator, Arg1: u64, Arg2: u64): u64 {
L3:	loc0: u8
L4:	loc1: u64
L5:	loc2: u256
L6:	loc3: &mut RandomGenerator
L7:	loc4: u8
L8:	loc5: u64
L9:	loc6: u64
L10:	loc7: vector<u8>
L11:	loc8: u8
L12:	loc9: u256
L13:	loc10: u256
L14:	loc11: u256
L15:	loc12: u8
B0:
	0: MoveLoc[1](Arg1: u64)
	1: StLoc[9](loc6: u64)
	2: MoveLoc[2](Arg2: u64)
	3: StLoc[8](loc5: u64)
	4: CopyLoc[9](loc6: u64)
	5: CopyLoc[8](loc5: u64)
	6: Le
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut RandomGenerator)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: CopyLoc[9](loc6: u64)
	14: CopyLoc[8](loc5: u64)
	15: Eq
	16: BrFalse(22)
B4:
	17: MoveLoc[0](Arg0: &mut RandomGenerator)
	18: Pop
	19: MoveLoc[9](loc6: u64)
	20: StLoc[4](loc1: u64)
	21: Branch(89)
B5:
	22: MoveLoc[8](loc5: u64)
	23: CopyLoc[9](loc6: u64)
	24: Sub
	25: CastU256
	26: LdU256(1)
	27: Add
	28: StLoc[13](loc10: u256)
	29: MoveLoc[0](Arg0: &mut RandomGenerator)
	30: StLoc[6](loc3: &mut RandomGenerator)
	31: LdU8(16)
	32: StLoc[11](loc8: u8)
	33: CopyLoc[6](loc3: &mut RandomGenerator)
	34: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	35: VecLen(17)
	36: CopyLoc[11](loc8: u8)
	37: CastU64
	38: Lt
	39: BrFalse(47)
B6:
	40: CopyLoc[6](loc3: &mut RandomGenerator)
	41: Call derive_next_block(&mut RandomGenerator): vector<u8>
	42: StLoc[10](loc7: vector<u8>)
	43: CopyLoc[6](loc3: &mut RandomGenerator)
	44: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	45: MoveLoc[10](loc7: vector<u8>)
	46: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B7:
	47: LdU256(0)
	48: StLoc[14](loc11: u256)
	49: MoveLoc[11](loc8: u8)
	50: StLoc[3](loc0: u8)
	51: LdU8(0)
	52: StLoc[7](loc4: u8)
	53: MoveLoc[3](loc0: u8)
	54: StLoc[15](loc12: u8)
B8:
	55: CopyLoc[7](loc4: u8)
	56: CopyLoc[15](loc12: u8)
	57: Lt
	58: BrFalse(77)
B9:
	59: CopyLoc[7](loc4: u8)
	60: Pop
	61: CopyLoc[6](loc3: &mut RandomGenerator)
	62: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	63: VecPopBack(17)
	64: CastU256
	65: StLoc[5](loc2: u256)
	66: MoveLoc[14](loc11: u256)
	67: LdU8(8)
	68: Shl
	69: MoveLoc[5](loc2: u256)
	70: Add
	71: StLoc[14](loc11: u256)
	72: MoveLoc[7](loc4: u8)
	73: LdU8(1)
	74: Add
	75: StLoc[7](loc4: u8)
	76: Branch(55)
B10:
	77: MoveLoc[6](loc3: &mut RandomGenerator)
	78: Pop
	79: MoveLoc[14](loc11: u256)
	80: CastU256
	81: StLoc[12](loc9: u256)
	82: MoveLoc[9](loc6: u64)
	83: MoveLoc[12](loc9: u256)
	84: MoveLoc[13](loc10: u256)
	85: Mod
	86: CastU64
	87: Add
	88: StLoc[4](loc1: u64)
B11:
	89: MoveLoc[4](loc1: u64)
	90: Ret
}

public generate_u32_in_range(Arg0: &mut RandomGenerator, Arg1: u32, Arg2: u32): u32 {
L3:	loc0: u8
L4:	loc1: u32
L5:	loc2: u256
L6:	loc3: &mut RandomGenerator
L7:	loc4: u8
L8:	loc5: u32
L9:	loc6: u32
L10:	loc7: vector<u8>
L11:	loc8: u8
L12:	loc9: u256
L13:	loc10: u256
L14:	loc11: u256
L15:	loc12: u8
B0:
	0: MoveLoc[1](Arg1: u32)
	1: StLoc[9](loc6: u32)
	2: MoveLoc[2](Arg2: u32)
	3: StLoc[8](loc5: u32)
	4: CopyLoc[9](loc6: u32)
	5: CopyLoc[8](loc5: u32)
	6: Le
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut RandomGenerator)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: CopyLoc[9](loc6: u32)
	14: CopyLoc[8](loc5: u32)
	15: Eq
	16: BrFalse(22)
B4:
	17: MoveLoc[0](Arg0: &mut RandomGenerator)
	18: Pop
	19: MoveLoc[9](loc6: u32)
	20: StLoc[4](loc1: u32)
	21: Branch(89)
B5:
	22: MoveLoc[8](loc5: u32)
	23: CopyLoc[9](loc6: u32)
	24: Sub
	25: CastU256
	26: LdU256(1)
	27: Add
	28: StLoc[13](loc10: u256)
	29: MoveLoc[0](Arg0: &mut RandomGenerator)
	30: StLoc[6](loc3: &mut RandomGenerator)
	31: LdU8(12)
	32: StLoc[11](loc8: u8)
	33: CopyLoc[6](loc3: &mut RandomGenerator)
	34: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	35: VecLen(17)
	36: CopyLoc[11](loc8: u8)
	37: CastU64
	38: Lt
	39: BrFalse(47)
B6:
	40: CopyLoc[6](loc3: &mut RandomGenerator)
	41: Call derive_next_block(&mut RandomGenerator): vector<u8>
	42: StLoc[10](loc7: vector<u8>)
	43: CopyLoc[6](loc3: &mut RandomGenerator)
	44: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	45: MoveLoc[10](loc7: vector<u8>)
	46: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B7:
	47: LdU256(0)
	48: StLoc[14](loc11: u256)
	49: MoveLoc[11](loc8: u8)
	50: StLoc[3](loc0: u8)
	51: LdU8(0)
	52: StLoc[7](loc4: u8)
	53: MoveLoc[3](loc0: u8)
	54: StLoc[15](loc12: u8)
B8:
	55: CopyLoc[7](loc4: u8)
	56: CopyLoc[15](loc12: u8)
	57: Lt
	58: BrFalse(77)
B9:
	59: CopyLoc[7](loc4: u8)
	60: Pop
	61: CopyLoc[6](loc3: &mut RandomGenerator)
	62: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	63: VecPopBack(17)
	64: CastU256
	65: StLoc[5](loc2: u256)
	66: MoveLoc[14](loc11: u256)
	67: LdU8(8)
	68: Shl
	69: MoveLoc[5](loc2: u256)
	70: Add
	71: StLoc[14](loc11: u256)
	72: MoveLoc[7](loc4: u8)
	73: LdU8(1)
	74: Add
	75: StLoc[7](loc4: u8)
	76: Branch(55)
B10:
	77: MoveLoc[6](loc3: &mut RandomGenerator)
	78: Pop
	79: MoveLoc[14](loc11: u256)
	80: CastU256
	81: StLoc[12](loc9: u256)
	82: MoveLoc[9](loc6: u32)
	83: MoveLoc[12](loc9: u256)
	84: MoveLoc[13](loc10: u256)
	85: Mod
	86: CastU32
	87: Add
	88: StLoc[4](loc1: u32)
B11:
	89: MoveLoc[4](loc1: u32)
	90: Ret
}

public generate_u16_in_range(Arg0: &mut RandomGenerator, Arg1: u16, Arg2: u16): u16 {
L3:	loc0: u8
L4:	loc1: u16
L5:	loc2: u256
L6:	loc3: &mut RandomGenerator
L7:	loc4: u8
L8:	loc5: u16
L9:	loc6: u16
L10:	loc7: vector<u8>
L11:	loc8: u8
L12:	loc9: u256
L13:	loc10: u256
L14:	loc11: u256
L15:	loc12: u8
B0:
	0: MoveLoc[1](Arg1: u16)
	1: StLoc[9](loc6: u16)
	2: MoveLoc[2](Arg2: u16)
	3: StLoc[8](loc5: u16)
	4: CopyLoc[9](loc6: u16)
	5: CopyLoc[8](loc5: u16)
	6: Le
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut RandomGenerator)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: CopyLoc[9](loc6: u16)
	14: CopyLoc[8](loc5: u16)
	15: Eq
	16: BrFalse(22)
B4:
	17: MoveLoc[0](Arg0: &mut RandomGenerator)
	18: Pop
	19: MoveLoc[9](loc6: u16)
	20: StLoc[4](loc1: u16)
	21: Branch(89)
B5:
	22: MoveLoc[8](loc5: u16)
	23: CopyLoc[9](loc6: u16)
	24: Sub
	25: CastU256
	26: LdU256(1)
	27: Add
	28: StLoc[13](loc10: u256)
	29: MoveLoc[0](Arg0: &mut RandomGenerator)
	30: StLoc[6](loc3: &mut RandomGenerator)
	31: LdU8(10)
	32: StLoc[11](loc8: u8)
	33: CopyLoc[6](loc3: &mut RandomGenerator)
	34: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	35: VecLen(17)
	36: CopyLoc[11](loc8: u8)
	37: CastU64
	38: Lt
	39: BrFalse(47)
B6:
	40: CopyLoc[6](loc3: &mut RandomGenerator)
	41: Call derive_next_block(&mut RandomGenerator): vector<u8>
	42: StLoc[10](loc7: vector<u8>)
	43: CopyLoc[6](loc3: &mut RandomGenerator)
	44: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	45: MoveLoc[10](loc7: vector<u8>)
	46: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B7:
	47: LdU256(0)
	48: StLoc[14](loc11: u256)
	49: MoveLoc[11](loc8: u8)
	50: StLoc[3](loc0: u8)
	51: LdU8(0)
	52: StLoc[7](loc4: u8)
	53: MoveLoc[3](loc0: u8)
	54: StLoc[15](loc12: u8)
B8:
	55: CopyLoc[7](loc4: u8)
	56: CopyLoc[15](loc12: u8)
	57: Lt
	58: BrFalse(77)
B9:
	59: CopyLoc[7](loc4: u8)
	60: Pop
	61: CopyLoc[6](loc3: &mut RandomGenerator)
	62: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	63: VecPopBack(17)
	64: CastU256
	65: StLoc[5](loc2: u256)
	66: MoveLoc[14](loc11: u256)
	67: LdU8(8)
	68: Shl
	69: MoveLoc[5](loc2: u256)
	70: Add
	71: StLoc[14](loc11: u256)
	72: MoveLoc[7](loc4: u8)
	73: LdU8(1)
	74: Add
	75: StLoc[7](loc4: u8)
	76: Branch(55)
B10:
	77: MoveLoc[6](loc3: &mut RandomGenerator)
	78: Pop
	79: MoveLoc[14](loc11: u256)
	80: CastU256
	81: StLoc[12](loc9: u256)
	82: MoveLoc[9](loc6: u16)
	83: MoveLoc[12](loc9: u256)
	84: MoveLoc[13](loc10: u256)
	85: Mod
	86: CastU16
	87: Add
	88: StLoc[4](loc1: u16)
B11:
	89: MoveLoc[4](loc1: u16)
	90: Ret
}

public generate_u8_in_range(Arg0: &mut RandomGenerator, Arg1: u8, Arg2: u8): u8 {
L3:	loc0: u8
L4:	loc1: u8
L5:	loc2: u256
L6:	loc3: &mut RandomGenerator
L7:	loc4: u8
L8:	loc5: u8
L9:	loc6: u8
L10:	loc7: vector<u8>
L11:	loc8: u8
L12:	loc9: u256
L13:	loc10: u256
L14:	loc11: u256
L15:	loc12: u8
B0:
	0: MoveLoc[1](Arg1: u8)
	1: StLoc[9](loc6: u8)
	2: MoveLoc[2](Arg2: u8)
	3: StLoc[8](loc5: u8)
	4: CopyLoc[9](loc6: u8)
	5: CopyLoc[8](loc5: u8)
	6: Le
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut RandomGenerator)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: CopyLoc[9](loc6: u8)
	14: CopyLoc[8](loc5: u8)
	15: Eq
	16: BrFalse(22)
B4:
	17: MoveLoc[0](Arg0: &mut RandomGenerator)
	18: Pop
	19: MoveLoc[9](loc6: u8)
	20: StLoc[4](loc1: u8)
	21: Branch(89)
B5:
	22: MoveLoc[8](loc5: u8)
	23: CopyLoc[9](loc6: u8)
	24: Sub
	25: CastU256
	26: LdU256(1)
	27: Add
	28: StLoc[13](loc10: u256)
	29: MoveLoc[0](Arg0: &mut RandomGenerator)
	30: StLoc[6](loc3: &mut RandomGenerator)
	31: LdU8(9)
	32: StLoc[11](loc8: u8)
	33: CopyLoc[6](loc3: &mut RandomGenerator)
	34: ImmBorrowField[7](RandomGenerator.buffer: vector<u8>)
	35: VecLen(17)
	36: CopyLoc[11](loc8: u8)
	37: CastU64
	38: Lt
	39: BrFalse(47)
B6:
	40: CopyLoc[6](loc3: &mut RandomGenerator)
	41: Call derive_next_block(&mut RandomGenerator): vector<u8>
	42: StLoc[10](loc7: vector<u8>)
	43: CopyLoc[6](loc3: &mut RandomGenerator)
	44: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	45: MoveLoc[10](loc7: vector<u8>)
	46: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
B7:
	47: LdU256(0)
	48: StLoc[14](loc11: u256)
	49: MoveLoc[11](loc8: u8)
	50: StLoc[3](loc0: u8)
	51: LdU8(0)
	52: StLoc[7](loc4: u8)
	53: MoveLoc[3](loc0: u8)
	54: StLoc[15](loc12: u8)
B8:
	55: CopyLoc[7](loc4: u8)
	56: CopyLoc[15](loc12: u8)
	57: Lt
	58: BrFalse(77)
B9:
	59: CopyLoc[7](loc4: u8)
	60: Pop
	61: CopyLoc[6](loc3: &mut RandomGenerator)
	62: MutBorrowField[7](RandomGenerator.buffer: vector<u8>)
	63: VecPopBack(17)
	64: CastU256
	65: StLoc[5](loc2: u256)
	66: MoveLoc[14](loc11: u256)
	67: LdU8(8)
	68: Shl
	69: MoveLoc[5](loc2: u256)
	70: Add
	71: StLoc[14](loc11: u256)
	72: MoveLoc[7](loc4: u8)
	73: LdU8(1)
	74: Add
	75: StLoc[7](loc4: u8)
	76: Branch(55)
B10:
	77: MoveLoc[6](loc3: &mut RandomGenerator)
	78: Pop
	79: MoveLoc[14](loc11: u256)
	80: CastU256
	81: StLoc[12](loc9: u256)
	82: MoveLoc[9](loc6: u8)
	83: MoveLoc[12](loc9: u256)
	84: MoveLoc[13](loc10: u256)
	85: Mod
	86: CastU8
	87: Add
	88: StLoc[4](loc1: u8)
B11:
	89: MoveLoc[4](loc1: u8)
	90: Ret
}

public shuffle<Ty0>(Arg0: &mut RandomGenerator, Arg1: &mut vector<Ty0>) {
L2:	loc0: u16
L3:	loc1: u16
L4:	loc2: u16
L5:	loc3: u16
L6:	loc4: u16
L7:	loc5: u64
L8:	loc6: u16
B0:
	0: CopyLoc[1](Arg1: &mut vector<Ty0>)
	1: FreezeRef
	2: VecLen(33)
	3: StLoc[7](loc5: u64)
	4: CopyLoc[7](loc5: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(13)
B1:
	8: MoveLoc[1](Arg1: &mut vector<Ty0>)
	9: Pop
	10: MoveLoc[0](Arg0: &mut RandomGenerator)
	11: Pop
	12: Ret
B2:
	13: CopyLoc[7](loc5: u64)
	14: LdConst[6](u64: 65535)
	15: Le
	16: BrFalse(18)
B3:
	17: Branch(24)
B4:
	18: MoveLoc[1](Arg1: &mut vector<Ty0>)
	19: Pop
	20: MoveLoc[0](Arg0: &mut RandomGenerator)
	21: Pop
	22: LdConst[4](u64: 4)
	23: Abort
B5:
	24: MoveLoc[7](loc5: u64)
	25: CastU16
	26: LdU16(1)
	27: Sub
	28: StLoc[3](loc1: u16)
	29: CopyLoc[3](loc1: u16)
	30: StLoc[2](loc0: u16)
	31: LdU16(0)
	32: StLoc[4](loc2: u16)
	33: MoveLoc[2](loc0: u16)
	34: StLoc[8](loc6: u16)
B6:
	35: CopyLoc[4](loc2: u16)
	36: CopyLoc[8](loc6: u16)
	37: Lt
	38: BrFalse(57)
B7:
	39: CopyLoc[4](loc2: u16)
	40: StLoc[5](loc3: u16)
	41: CopyLoc[0](Arg0: &mut RandomGenerator)
	42: CopyLoc[5](loc3: u16)
	43: CopyLoc[3](loc1: u16)
	44: Call generate_u16_in_range(&mut RandomGenerator, u16, u16): u16
	45: StLoc[6](loc4: u16)
	46: CopyLoc[1](Arg1: &mut vector<Ty0>)
	47: MoveLoc[5](loc3: u16)
	48: CastU64
	49: MoveLoc[6](loc4: u16)
	50: CastU64
	51: VecSwap(33)
	52: MoveLoc[4](loc2: u16)
	53: LdU16(1)
	54: Add
	55: StLoc[4](loc2: u16)
	56: Branch(35)
B8:
	57: MoveLoc[1](Arg1: &mut vector<Ty0>)
	58: Pop
	59: MoveLoc[0](Arg0: &mut RandomGenerator)
	60: Pop
	61: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u16: 32
	6 => u64: 65535
	7 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
	8 => vector<u8>: "" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 2.safe {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::url;
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct SAFE has drop {
	dummy_field: bool
}

new(Arg0: &mut TxContext): Balance<SAFE> {
L1:	loc0: CoinMetadata<SAFE>
L2:	loc1: Supply<SAFE>
L3:	loc2: Balance<SAFE>
L4:	loc3: TreasuryCap<SAFE>
B0:
	0: CopyLoc[0](Arg0: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: LdConst[5](address: 0x00..)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut TxContext)
	8: Pop
	9: LdConst[1](u64: 1)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut TxContext)
	12: FreezeRef
	13: Call tx_context::epoch(&TxContext): u64
	14: LdU64(0)
	15: Eq
	16: BrFalse(18)
B4:
	17: Branch(22)
B5:
	18: MoveLoc[0](Arg0: &mut TxContext)
	19: Pop
	20: LdConst[0](u64: 0)
	21: Abort
B6:
	22: LdFalse
	23: Pack[0](SAFE)
	24: LdU8(9)
	25: LdConst[6](vector<u8>: "SAF..)
	26: LdConst[7](vector<u8>: "Saf..)
	27: LdConst[8](vector<u8>: "SAF..)
	28: LdConst[9](vector<u8>: "htt..)
	29: Call url::new_unsafe_from_bytes(vector<u8>): Url
	30: Call option::some<Url>(Url): Option<Url>
	31: MoveLoc[0](Arg0: &mut TxContext)
	32: Call coin::create_currency<SAFE>(SAFE, u8, vector<u8>, vector<u8>, vector<u8>, Option<Url>, &mut TxContext): TreasuryCap<SAFE> * CoinMetadata<SAFE>
	33: StLoc[1](loc0: CoinMetadata<SAFE>)
	34: StLoc[4](loc3: TreasuryCap<SAFE>)
	35: MoveLoc[1](loc0: CoinMetadata<SAFE>)
	36: Call transfer::public_freeze_object<CoinMetadata<SAFE>>(CoinMetadata<SAFE>)
	37: MoveLoc[4](loc3: TreasuryCap<SAFE>)
	38: Call coin::treasury_into_supply<SAFE>(TreasuryCap<SAFE>): Supply<SAFE>
	39: StLoc[2](loc1: Supply<SAFE>)
	40: MutBorrowLoc[2](loc1: Supply<SAFE>)
	41: LdConst[4](u64: 3600..)
	42: Call balance::increase_supply<SAFE>(&mut Supply<SAFE>, u64): Balance<SAFE>
	43: StLoc[3](loc2: Balance<SAFE>)
	44: MoveLoc[2](loc1: Supply<SAFE>)
	45: Call balance::destroy_supply<SAFE>(Supply<SAFE>): u64
	46: Pop
	47: MoveLoc[3](loc2: Balance<SAFE>)
	48: Ret
}

entry public transfer(Arg0: Coin<SAFE>, Arg1: address) {
B0:
	0: MoveLoc[0](Arg0: Coin<SAFE>)
	1: MoveLoc[1](Arg1: address)
	2: Call transfer::public_transfer<Coin<SAFE>>(Coin<SAFE>, address)
	3: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 1000000000
	3 => u64: 36000000
	4 => u64: 36000000000000000
	5 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
	6 => vector<u8>: "SAFE" // interpreted as UTF8 string
	7 => vector<u8>: "Safe" // interpreted as UTF8 string
	8 => vector<u8>: "SAFE is the native token of the Safe network, used to pay for gas and to stake with validators. Fixed maximum supply of 36,000,000 SAFE." // interpreted as UTF8 string
	9 => vector<u8>: "https://s2.coinmarketcap.com/static/img/coins/128x128/3799.png" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 2.table {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Table<phantom Ty0: copy + drop + store, phantom Ty1: store> has store, key {
	id: UID,
	size: u64
}

public new<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut TxContext): Table<Ty0, Ty1> {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: LdU64(0)
	3: PackGeneric[0](Table<Ty0, Ty1>)
	4: Ret
}

public add<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut Table<Ty0, Ty1>, Arg1: Ty0, Arg2: Ty1) {
B0:
	0: CopyLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](Table.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: MoveLoc[2](Arg2: Ty1)
	4: Call dynamic_field::add<Ty0, Ty1>(&mut UID, Ty0, Ty1)
	5: CopyLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	6: ImmBorrowFieldGeneric[1](Table.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Add
	10: MoveLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	11: MutBorrowFieldGeneric[1](Table.size: u64)
	12: WriteRef
	13: Ret
}

public borrow<Ty0: copy + drop + store, Ty1: store>(Arg0: &Table<Ty0, Ty1>, Arg1: Ty0): &Ty1 {
B0:
	0: MoveLoc[0](Arg0: &Table<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](Table.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow<Ty0, Ty1>(&UID, Ty0): &Ty1
	4: Ret
}

public borrow_mut<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut Table<Ty0, Ty1>, Arg1: Ty0): &mut Ty1 {
B0:
	0: MoveLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](Table.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::borrow_mut<Ty0, Ty1>(&mut UID, Ty0): &mut Ty1
	4: Ret
}

public remove<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut Table<Ty0, Ty1>, Arg1: Ty0): Ty1 {
L2:	loc0: Ty1
B0:
	0: CopyLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	1: MutBorrowFieldGeneric[0](Table.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::remove<Ty0, Ty1>(&mut UID, Ty0): Ty1
	4: StLoc[2](loc0: Ty1)
	5: CopyLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	6: ImmBorrowFieldGeneric[1](Table.size: u64)
	7: ReadRef
	8: LdU64(1)
	9: Sub
	10: MoveLoc[0](Arg0: &mut Table<Ty0, Ty1>)
	11: MutBorrowFieldGeneric[1](Table.size: u64)
	12: WriteRef
	13: MoveLoc[2](loc0: Ty1)
	14: Ret
}

public contains<Ty0: copy + drop + store, Ty1: store>(Arg0: &Table<Ty0, Ty1>, Arg1: Ty0): bool {
B0:
	0: MoveLoc[0](Arg0: &Table<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](Table.id: UID)
	2: MoveLoc[1](Arg1: Ty0)
	3: Call dynamic_field::exists_with_type<Ty0, Ty1>(&UID, Ty0): bool
	4: Ret
}

public length<Ty0: copy + drop + store, Ty1: store>(Arg0: &Table<Ty0, Ty1>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Table<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[1](Table.size: u64)
	2: ReadRef
	3: Ret
}

public is_empty<Ty0: copy + drop + store, Ty1: store>(Arg0: &Table<Ty0, Ty1>): bool {
B0:
	0: MoveLoc[0](Arg0: &Table<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[1](Table.size: u64)
	2: ReadRef
	3: LdU64(0)
	4: Eq
	5: Ret
}

public destroy_empty<Ty0: copy + drop + store, Ty1: store>(Arg0: Table<Ty0, Ty1>) {
L1:	loc0: UID
L2:	loc1: u64
B0:
	0: MoveLoc[0](Arg0: Table<Ty0, Ty1>)
	1: UnpackGeneric[0](Table<Ty0, Ty1>)
	2: StLoc[2](loc1: u64)
	3: StLoc[1](loc0: UID)
	4: MoveLoc[2](loc1: u64)
	5: LdU64(0)
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(11)
B2:
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[1](loc0: UID)
	12: Call object::delete(UID)
	13: Ret
}

public drop<Ty0: copy + drop + store, Ty1: drop + store>(Arg0: Table<Ty0, Ty1>) {
B0:
	0: MoveLoc[0](Arg0: Table<Ty0, Ty1>)
	1: UnpackGeneric[0](Table<Ty0, Ty1>)
	2: Pop
	3: Call object::delete(UID)
	4: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.table_vec {
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct TableVec<phantom Ty0: store> has store {
	contents: Table<u64, Ty0>
}

public empty<Ty0: store>(Arg0: &mut TxContext): TableVec<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call table::new<u64, Ty0>(&mut TxContext): Table<u64, Ty0>
	2: PackGeneric[0](TableVec<Ty0>)
	3: Ret
}

public singleton<Ty0: store>(Arg0: Ty0, Arg1: &mut TxContext): TableVec<Ty0> {
L2:	loc0: TableVec<Ty0>
B0:
	0: MoveLoc[1](Arg1: &mut TxContext)
	1: Call empty<Ty0>(&mut TxContext): TableVec<Ty0>
	2: StLoc[2](loc0: TableVec<Ty0>)
	3: MutBorrowLoc[2](loc0: TableVec<Ty0>)
	4: MoveLoc[0](Arg0: Ty0)
	5: Call push_back<Ty0>(&mut TableVec<Ty0>, Ty0)
	6: MoveLoc[2](loc0: TableVec<Ty0>)
	7: Ret
}

public length<Ty0: store>(Arg0: &TableVec<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &TableVec<Ty0>)
	1: ImmBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	2: Call table::length<u64, Ty0>(&Table<u64, Ty0>): u64
	3: Ret
}

public is_empty<Ty0: store>(Arg0: &TableVec<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &TableVec<Ty0>)
	1: Call length<Ty0>(&TableVec<Ty0>): u64
	2: LdU64(0)
	3: Eq
	4: Ret
}

public borrow<Ty0: store>(Arg0: &TableVec<Ty0>, Arg1: u64): &Ty0 {
B0:
	0: CopyLoc[0](Arg0: &TableVec<Ty0>)
	1: Call length<Ty0>(&TableVec<Ty0>): u64
	2: CopyLoc[1](Arg1: u64)
	3: Gt
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &TableVec<Ty0>)
	7: Pop
	8: LdConst[0](u64: 0)
	9: Abort
B3:
	10: MoveLoc[0](Arg0: &TableVec<Ty0>)
	11: ImmBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	12: MoveLoc[1](Arg1: u64)
	13: Call table::borrow<u64, Ty0>(&Table<u64, Ty0>, u64): &Ty0
	14: Ret
}

public push_back<Ty0: store>(Arg0: &mut TableVec<Ty0>, Arg1: Ty0) {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	1: FreezeRef
	2: Call length<Ty0>(&TableVec<Ty0>): u64
	3: StLoc[2](loc0: u64)
	4: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	5: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	6: MoveLoc[2](loc0: u64)
	7: MoveLoc[1](Arg1: Ty0)
	8: Call table::add<u64, Ty0>(&mut Table<u64, Ty0>, u64, Ty0)
	9: Ret
}

public borrow_mut<Ty0: store>(Arg0: &mut TableVec<Ty0>, Arg1: u64): &mut Ty0 {
B0:
	0: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	1: FreezeRef
	2: Call length<Ty0>(&TableVec<Ty0>): u64
	3: CopyLoc[1](Arg1: u64)
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	12: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	13: MoveLoc[1](Arg1: u64)
	14: Call table::borrow_mut<u64, Ty0>(&mut Table<u64, Ty0>, u64): &mut Ty0
	15: Ret
}

public pop_back<Ty0: store>(Arg0: &mut TableVec<Ty0>): Ty0 {
L1:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	1: FreezeRef
	2: Call length<Ty0>(&TableVec<Ty0>): u64
	3: StLoc[1](loc0: u64)
	4: CopyLoc[1](loc0: u64)
	5: LdU64(0)
	6: Gt
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	14: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	15: MoveLoc[1](loc0: u64)
	16: LdU64(1)
	17: Sub
	18: Call table::remove<u64, Ty0>(&mut Table<u64, Ty0>, u64): Ty0
	19: Ret
}

public destroy_empty<Ty0: store>(Arg0: TableVec<Ty0>) {
B0:
	0: ImmBorrowLoc[0](Arg0: TableVec<Ty0>)
	1: Call length<Ty0>(&TableVec<Ty0>): u64
	2: LdU64(0)
	3: Eq
	4: BrFalse(6)
B1:
	5: Branch(8)
B2:
	6: LdConst[1](u64: 1)
	7: Abort
B3:
	8: MoveLoc[0](Arg0: TableVec<Ty0>)
	9: UnpackGeneric[0](TableVec<Ty0>)
	10: Call table::destroy_empty<u64, Ty0>(Table<u64, Ty0>)
	11: Ret
}

public drop<Ty0: drop + store>(Arg0: TableVec<Ty0>) {
B0:
	0: MoveLoc[0](Arg0: TableVec<Ty0>)
	1: UnpackGeneric[0](TableVec<Ty0>)
	2: Call table::drop<u64, Ty0>(Table<u64, Ty0>)
	3: Ret
}

public swap<Ty0: store>(Arg0: &mut TableVec<Ty0>, Arg1: u64, Arg2: u64) {
L3:	loc0: Ty0
L4:	loc1: Ty0
B0:
	0: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	1: FreezeRef
	2: Call length<Ty0>(&TableVec<Ty0>): u64
	3: CopyLoc[1](Arg1: u64)
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	12: FreezeRef
	13: Call length<Ty0>(&TableVec<Ty0>): u64
	14: CopyLoc[2](Arg2: u64)
	15: Gt
	16: BrFalse(18)
B4:
	17: Branch(22)
B5:
	18: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	19: Pop
	20: LdConst[0](u64: 0)
	21: Abort
B6:
	22: CopyLoc[1](Arg1: u64)
	23: CopyLoc[2](Arg2: u64)
	24: Eq
	25: BrFalse(29)
B7:
	26: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	27: Pop
	28: Ret
B8:
	29: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	30: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	31: CopyLoc[1](Arg1: u64)
	32: Call table::remove<u64, Ty0>(&mut Table<u64, Ty0>, u64): Ty0
	33: StLoc[3](loc0: Ty0)
	34: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	35: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	36: CopyLoc[2](Arg2: u64)
	37: Call table::remove<u64, Ty0>(&mut Table<u64, Ty0>, u64): Ty0
	38: StLoc[4](loc1: Ty0)
	39: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	40: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	41: MoveLoc[2](Arg2: u64)
	42: MoveLoc[3](loc0: Ty0)
	43: Call table::add<u64, Ty0>(&mut Table<u64, Ty0>, u64, Ty0)
	44: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	45: MutBorrowFieldGeneric[0](TableVec.contents: Table<u64, Ty0>)
	46: MoveLoc[1](Arg1: u64)
	47: MoveLoc[4](loc1: Ty0)
	48: Call table::add<u64, Ty0>(&mut Table<u64, Ty0>, u64, Ty0)
	49: Ret
}

public swap_remove<Ty0: store>(Arg0: &mut TableVec<Ty0>, Arg1: u64): Ty0 {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	1: FreezeRef
	2: Call length<Ty0>(&TableVec<Ty0>): u64
	3: CopyLoc[1](Arg1: u64)
	4: Gt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	12: FreezeRef
	13: Call length<Ty0>(&TableVec<Ty0>): u64
	14: LdU64(1)
	15: Sub
	16: StLoc[2](loc0: u64)
	17: CopyLoc[0](Arg0: &mut TableVec<Ty0>)
	18: MoveLoc[1](Arg1: u64)
	19: MoveLoc[2](loc0: u64)
	20: Call swap<Ty0>(&mut TableVec<Ty0>, u64, u64)
	21: MoveLoc[0](Arg0: &mut TableVec<Ty0>)
	22: Call pop_back<Ty0>(&mut TableVec<Ty0>): Ty0
	23: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
]
}

// Move bytecode v6
module 2.token {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

struct Token<phantom Ty0> has key {
	id: UID,
	balance: Balance<Ty0>
}

struct TokenPolicyCap<phantom Ty0> has store, key {
	id: UID,
	for: ID
}

struct TokenPolicy<phantom Ty0> has key {
	id: UID,
	spent_balance: Balance<Ty0>,
	rules: VecMap<String, VecSet<TypeName>>
}

struct ActionRequest<phantom Ty0> {
	name: String,
	amount: u64,
	sender: address,
	recipient: Option<address>,
	spent_balance: Option<Balance<Ty0>>,
	approvals: VecSet<TypeName>
}

struct RuleKey<phantom Ty0> has copy, drop, store {
	is_protected: bool
}

struct TokenPolicyCreated<phantom Ty0> has copy, drop {
	id: ID,
	is_mutable: bool
}

public new_policy<Ty0>(Arg0: &TreasuryCap<Ty0>, Arg1: &mut TxContext): TokenPolicy<Ty0> * TokenPolicyCap<Ty0> {
L2:	loc0: TokenPolicyCap<Ty0>
L3:	loc1: TokenPolicy<Ty0>
B0:
	0: CopyLoc[1](Arg1: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Call balance::zero<Ty0>(): Balance<Ty0>
	3: Call vec_map::empty<String, VecSet<TypeName>>(): VecMap<String, VecSet<TypeName>>
	4: PackGeneric[0](TokenPolicy<Ty0>)
	5: StLoc[3](loc1: TokenPolicy<Ty0>)
	6: MoveLoc[1](Arg1: &mut TxContext)
	7: Call object::new(&mut TxContext): UID
	8: ImmBorrowLoc[3](loc1: TokenPolicy<Ty0>)
	9: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	10: PackGeneric[1](TokenPolicyCap<Ty0>)
	11: StLoc[2](loc0: TokenPolicyCap<Ty0>)
	12: MoveLoc[3](loc1: TokenPolicy<Ty0>)
	13: MoveLoc[2](loc0: TokenPolicyCap<Ty0>)
	14: Ret
}

public share_policy<Ty0>(Arg0: TokenPolicy<Ty0>) {
B0:
	0: ImmBorrowLoc[0](Arg0: TokenPolicy<Ty0>)
	1: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	2: LdTrue
	3: PackGeneric[2](TokenPolicyCreated<Ty0>)
	4: Call event::emit<TokenPolicyCreated<Ty0>>(TokenPolicyCreated<Ty0>)
	5: MoveLoc[0](Arg0: TokenPolicy<Ty0>)
	6: Call transfer::share_object<TokenPolicy<Ty0>>(TokenPolicy<Ty0>)
	7: Ret
}

public transfer<Ty0>(Arg0: Token<Ty0>, Arg1: address, Arg2: &mut TxContext): ActionRequest<Ty0> {
L3:	loc0: u64
B0:
	0: ImmBorrowLoc[0](Arg0: Token<Ty0>)
	1: ImmBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: StLoc[3](loc0: u64)
	4: MoveLoc[0](Arg0: Token<Ty0>)
	5: CopyLoc[1](Arg1: address)
	6: Call transfer::transfer<Token<Ty0>>(Token<Ty0>, address)
	7: Call transfer_action(): String
	8: MoveLoc[3](loc0: u64)
	9: MoveLoc[1](Arg1: address)
	10: Call option::some<address>(address): Option<address>
	11: Call option::none<Balance<Ty0>>(): Option<Balance<Ty0>>
	12: MoveLoc[2](Arg2: &mut TxContext)
	13: FreezeRef
	14: Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>
	15: Ret
}

public spend<Ty0>(Arg0: Token<Ty0>, Arg1: &mut TxContext): ActionRequest<Ty0> {
L2:	loc0: Balance<Ty0>
B0:
	0: MoveLoc[0](Arg0: Token<Ty0>)
	1: UnpackGeneric[3](Token<Ty0>)
	2: StLoc[2](loc0: Balance<Ty0>)
	3: Call object::delete(UID)
	4: Call spend_action(): String
	5: ImmBorrowLoc[2](loc0: Balance<Ty0>)
	6: Call balance::value<Ty0>(&Balance<Ty0>): u64
	7: Call option::none<address>(): Option<address>
	8: MoveLoc[2](loc0: Balance<Ty0>)
	9: Call option::some<Balance<Ty0>>(Balance<Ty0>): Option<Balance<Ty0>>
	10: MoveLoc[1](Arg1: &mut TxContext)
	11: FreezeRef
	12: Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>
	13: Ret
}

public to_coin<Ty0>(Arg0: Token<Ty0>, Arg1: &mut TxContext): Coin<Ty0> * ActionRequest<Ty0> {
L2:	loc0: u64
L3:	loc1: Balance<Ty0>
L4:	loc2: UID
B0:
	0: MoveLoc[0](Arg0: Token<Ty0>)
	1: UnpackGeneric[3](Token<Ty0>)
	2: StLoc[3](loc1: Balance<Ty0>)
	3: StLoc[4](loc2: UID)
	4: ImmBorrowLoc[3](loc1: Balance<Ty0>)
	5: Call balance::value<Ty0>(&Balance<Ty0>): u64
	6: StLoc[2](loc0: u64)
	7: MoveLoc[4](loc2: UID)
	8: Call object::delete(UID)
	9: MoveLoc[3](loc1: Balance<Ty0>)
	10: CopyLoc[1](Arg1: &mut TxContext)
	11: Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
	12: Call to_coin_action(): String
	13: MoveLoc[2](loc0: u64)
	14: Call option::none<address>(): Option<address>
	15: Call option::none<Balance<Ty0>>(): Option<Balance<Ty0>>
	16: MoveLoc[1](Arg1: &mut TxContext)
	17: FreezeRef
	18: Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>
	19: Ret
}

public from_coin<Ty0>(Arg0: Coin<Ty0>, Arg1: &mut TxContext): Token<Ty0> * ActionRequest<Ty0> {
L2:	loc0: u64
B0:
	0: ImmBorrowLoc[0](Arg0: Coin<Ty0>)
	1: Call coin::value<Ty0>(&Coin<Ty0>): u64
	2: StLoc[2](loc0: u64)
	3: CopyLoc[1](Arg1: &mut TxContext)
	4: Call object::new(&mut TxContext): UID
	5: MoveLoc[0](Arg0: Coin<Ty0>)
	6: Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
	7: PackGeneric[3](Token<Ty0>)
	8: Call from_coin_action(): String
	9: MoveLoc[2](loc0: u64)
	10: Call option::none<address>(): Option<address>
	11: Call option::none<Balance<Ty0>>(): Option<Balance<Ty0>>
	12: MoveLoc[1](Arg1: &mut TxContext)
	13: FreezeRef
	14: Call new_request<Ty0>(String, u64, Option<address>, Option<Balance<Ty0>>, &TxContext): ActionRequest<Ty0>
	15: Ret
}

public join<Ty0>(Arg0: &mut Token<Ty0>, Arg1: Token<Ty0>) {
L2:	loc0: Balance<Ty0>
L3:	loc1: UID
B0:
	0: MoveLoc[1](Arg1: Token<Ty0>)
	1: UnpackGeneric[3](Token<Ty0>)
	2: StLoc[2](loc0: Balance<Ty0>)
	3: StLoc[3](loc1: UID)
	4: MoveLoc[0](Arg0: &mut Token<Ty0>)
	5: MutBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)
	6: MoveLoc[2](loc0: Balance<Ty0>)
	7: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	8: Pop
	9: MoveLoc[3](loc1: UID)
	10: Call object::delete(UID)
	11: Ret
}

public split<Ty0>(Arg0: &mut Token<Ty0>, Arg1: u64, Arg2: &mut TxContext): Token<Ty0> {
B0:
	0: CopyLoc[0](Arg0: &mut Token<Ty0>)
	1: ImmBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: CopyLoc[1](Arg1: u64)
	4: Ge
	5: BrFalse(7)
B1:
	6: Branch(13)
B2:
	7: MoveLoc[0](Arg0: &mut Token<Ty0>)
	8: Pop
	9: MoveLoc[2](Arg2: &mut TxContext)
	10: Pop
	11: LdConst[3](u64: 3)
	12: Abort
B3:
	13: MoveLoc[2](Arg2: &mut TxContext)
	14: Call object::new(&mut TxContext): UID
	15: MoveLoc[0](Arg0: &mut Token<Ty0>)
	16: MutBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)
	17: MoveLoc[1](Arg1: u64)
	18: Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	19: PackGeneric[3](Token<Ty0>)
	20: Ret
}

public zero<Ty0>(Arg0: &mut TxContext): Token<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: Call balance::zero<Ty0>(): Balance<Ty0>
	3: PackGeneric[3](Token<Ty0>)
	4: Ret
}

public destroy_zero<Ty0>(Arg0: Token<Ty0>) {
L1:	loc0: Balance<Ty0>
L2:	loc1: UID
B0:
	0: MoveLoc[0](Arg0: Token<Ty0>)
	1: UnpackGeneric[3](Token<Ty0>)
	2: StLoc[1](loc0: Balance<Ty0>)
	3: StLoc[2](loc1: UID)
	4: ImmBorrowLoc[1](loc0: Balance<Ty0>)
	5: Call balance::value<Ty0>(&Balance<Ty0>): u64
	6: LdU64(0)
	7: Eq
	8: BrFalse(10)
B1:
	9: Branch(12)
B2:
	10: LdConst[4](u64: 4)
	11: Abort
B3:
	12: MoveLoc[1](loc0: Balance<Ty0>)
	13: Call balance::destroy_zero<Ty0>(Balance<Ty0>)
	14: MoveLoc[2](loc1: UID)
	15: Call object::delete(UID)
	16: Ret
}

public keep<Ty0>(Arg0: Token<Ty0>, Arg1: &mut TxContext) {
B0:
	0: MoveLoc[0](Arg0: Token<Ty0>)
	1: MoveLoc[1](Arg1: &mut TxContext)
	2: FreezeRef
	3: Call tx_context::sender(&TxContext): address
	4: Call transfer::transfer<Token<Ty0>>(Token<Ty0>, address)
	5: Ret
}

public new_request<Ty0>(Arg0: String, Arg1: u64, Arg2: Option<address>, Arg3: Option<Balance<Ty0>>, Arg4: &TxContext): ActionRequest<Ty0> {
L5:	loc0: String
L6:	loc1: u64
L7:	loc2: Option<address>
L8:	loc3: Option<Balance<Ty0>>
L9:	loc4: address
L10:	loc5: VecSet<TypeName>
B0:
	0: MoveLoc[0](Arg0: String)
	1: StLoc[5](loc0: String)
	2: MoveLoc[1](Arg1: u64)
	3: StLoc[6](loc1: u64)
	4: MoveLoc[2](Arg2: Option<address>)
	5: StLoc[7](loc2: Option<address>)
	6: MoveLoc[3](Arg3: Option<Balance<Ty0>>)
	7: StLoc[8](loc3: Option<Balance<Ty0>>)
	8: MoveLoc[4](Arg4: &TxContext)
	9: Call tx_context::sender(&TxContext): address
	10: StLoc[9](loc4: address)
	11: Call vec_set::empty<TypeName>(): VecSet<TypeName>
	12: StLoc[10](loc5: VecSet<TypeName>)
	13: MoveLoc[5](loc0: String)
	14: MoveLoc[6](loc1: u64)
	15: MoveLoc[9](loc4: address)
	16: MoveLoc[7](loc2: Option<address>)
	17: MoveLoc[8](loc3: Option<Balance<Ty0>>)
	18: MoveLoc[10](loc5: VecSet<TypeName>)
	19: PackGeneric[4](ActionRequest<Ty0>)
	20: Ret
}

public confirm_request<Ty0>(Arg0: &TokenPolicy<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {
L3:	loc0: vector<TypeName>
L4:	loc1: u64
L5:	loc2: VecSet<TypeName>
L6:	loc3: u64
L7:	loc4: String
L8:	loc5: Option<address>
L9:	loc6: &TypeName
L10:	loc7: &vector<TypeName>
L11:	loc8: u64
L12:	loc9: address
L13:	loc10: Option<Balance<Ty0>>
B0:
	0: ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)
	2: Call option::is_none<Balance<Ty0>>(&Option<Balance<Ty0>>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	6: Pop
	7: LdConst[5](u64: 5)
	8: Abort
B3:
	9: CopyLoc[0](Arg0: &TokenPolicy<Ty0>)
	10: ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	11: ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)
	12: ImmBorrowFieldGeneric[3](ActionRequest.name: String)
	13: Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool
	14: BrFalse(16)
B4:
	15: Branch(20)
B5:
	16: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	17: Pop
	18: LdConst[0](u64: 0)
	19: Abort
B6:
	20: MoveLoc[1](Arg1: ActionRequest<Ty0>)
	21: UnpackGeneric[4](ActionRequest<Ty0>)
	22: StLoc[5](loc2: VecSet<TypeName>)
	23: StLoc[13](loc10: Option<Balance<Ty0>>)
	24: StLoc[8](loc5: Option<address>)
	25: StLoc[12](loc9: address)
	26: StLoc[4](loc1: u64)
	27: StLoc[7](loc4: String)
	28: MoveLoc[13](loc10: Option<Balance<Ty0>>)
	29: Call option::destroy_none<Balance<Ty0>>(Option<Balance<Ty0>>)
	30: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	31: ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	32: ImmBorrowLoc[7](loc4: String)
	33: Call vec_map::get<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): &VecSet<TypeName>
	34: ReadRef
	35: Call vec_set::into_keys<TypeName>(VecSet<TypeName>): vector<TypeName>
	36: StLoc[3](loc0: vector<TypeName>)
	37: ImmBorrowLoc[3](loc0: vector<TypeName>)
	38: StLoc[10](loc7: &vector<TypeName>)
	39: CopyLoc[10](loc7: &vector<TypeName>)
	40: VecLen(65)
	41: StLoc[11](loc8: u64)
	42: LdU64(0)
	43: StLoc[6](loc3: u64)
B7:
	44: CopyLoc[6](loc3: u64)
	45: CopyLoc[11](loc8: u64)
	46: Lt
	47: BrFalse(66)
B8:
	48: CopyLoc[10](loc7: &vector<TypeName>)
	49: CopyLoc[6](loc3: u64)
	50: VecImmBorrow(65)
	51: StLoc[9](loc6: &TypeName)
	52: ImmBorrowLoc[5](loc2: VecSet<TypeName>)
	53: MoveLoc[9](loc6: &TypeName)
	54: Call vec_set::contains<TypeName>(&VecSet<TypeName>, &TypeName): bool
	55: BrFalse(57)
B9:
	56: Branch(61)
B10:
	57: MoveLoc[10](loc7: &vector<TypeName>)
	58: Pop
	59: LdConst[1](u64: 1)
	60: Abort
B11:
	61: MoveLoc[6](loc3: u64)
	62: LdU64(1)
	63: Add
	64: StLoc[6](loc3: u64)
	65: Branch(44)
B12:
	66: MoveLoc[10](loc7: &vector<TypeName>)
	67: Pop
	68: MoveLoc[7](loc4: String)
	69: MoveLoc[4](loc1: u64)
	70: MoveLoc[12](loc9: address)
	71: MoveLoc[8](loc5: Option<address>)
	72: Ret
}

public confirm_request_mut<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	2: ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)
	3: ImmBorrowFieldGeneric[3](ActionRequest.name: String)
	4: Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool
	5: BrFalse(7)
B1:
	6: Branch(13)
B2:
	7: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	8: Pop
	9: MoveLoc[2](Arg2: &mut TxContext)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)
	14: ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)
	15: Call option::is_some<Balance<Ty0>>(&Option<Balance<Ty0>>): bool
	16: BrFalse(18)
B4:
	17: Branch(24)
B5:
	18: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	19: Pop
	20: MoveLoc[2](Arg2: &mut TxContext)
	21: Pop
	22: LdConst[7](u64: 7)
	23: Abort
B6:
	24: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	25: MutBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)
	26: MutBorrowLoc[1](Arg1: ActionRequest<Ty0>)
	27: MutBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)
	28: Call option::extract<Balance<Ty0>>(&mut Option<Balance<Ty0>>): Balance<Ty0>
	29: Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
	30: Pop
	31: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	32: FreezeRef
	33: MoveLoc[1](Arg1: ActionRequest<Ty0>)
	34: MoveLoc[2](Arg2: &mut TxContext)
	35: Call confirm_request<Ty0>(&TokenPolicy<Ty0>, ActionRequest<Ty0>, &mut TxContext): String * u64 * address * Option<address>
	36: Ret
}

public confirm_with_policy_cap<Ty0>(Arg0: &TokenPolicyCap<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {
L3:	loc0: u64
L4:	loc1: String
L5:	loc2: Option<address>
L6:	loc3: address
L7:	loc4: Option<Balance<Ty0>>
B0:
	0: ImmBorrowLoc[1](Arg1: ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)
	2: Call option::is_none<Balance<Ty0>>(&Option<Balance<Ty0>>): bool
	3: BrFalse(5)
B1:
	4: Branch(7)
B2:
	5: LdConst[5](u64: 5)
	6: Abort
B3:
	7: MoveLoc[1](Arg1: ActionRequest<Ty0>)
	8: UnpackGeneric[4](ActionRequest<Ty0>)
	9: Pop
	10: StLoc[7](loc4: Option<Balance<Ty0>>)
	11: StLoc[5](loc2: Option<address>)
	12: StLoc[6](loc3: address)
	13: StLoc[3](loc0: u64)
	14: StLoc[4](loc1: String)
	15: MoveLoc[7](loc4: Option<Balance<Ty0>>)
	16: Call option::destroy_none<Balance<Ty0>>(Option<Balance<Ty0>>)
	17: MoveLoc[4](loc1: String)
	18: MoveLoc[3](loc0: u64)
	19: MoveLoc[6](loc3: address)
	20: MoveLoc[5](loc2: Option<address>)
	21: Ret
}

public confirm_with_treasury_cap<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: ActionRequest<Ty0>, Arg2: &mut TxContext): String * u64 * address * Option<address> {
L3:	loc0: u64
L4:	loc1: String
L5:	loc2: Option<address>
L6:	loc3: address
L7:	loc4: Option<Balance<Ty0>>
B0:
	0: MoveLoc[1](Arg1: ActionRequest<Ty0>)
	1: UnpackGeneric[4](ActionRequest<Ty0>)
	2: Pop
	3: StLoc[7](loc4: Option<Balance<Ty0>>)
	4: StLoc[5](loc2: Option<address>)
	5: StLoc[6](loc3: address)
	6: StLoc[3](loc0: u64)
	7: StLoc[4](loc1: String)
	8: ImmBorrowLoc[7](loc4: Option<Balance<Ty0>>)
	9: Call option::is_some<Balance<Ty0>>(&Option<Balance<Ty0>>): bool
	10: BrFalse(18)
B1:
	11: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	12: Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>
	13: MoveLoc[7](loc4: Option<Balance<Ty0>>)
	14: Call option::destroy_some<Balance<Ty0>>(Option<Balance<Ty0>>): Balance<Ty0>
	15: Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64
	16: Pop
	17: Branch(22)
B2:
	18: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	19: Pop
	20: MoveLoc[7](loc4: Option<Balance<Ty0>>)
	21: Call option::destroy_none<Balance<Ty0>>(Option<Balance<Ty0>>)
B3:
	22: MoveLoc[4](loc1: String)
	23: MoveLoc[3](loc0: u64)
	24: MoveLoc[6](loc3: address)
	25: MoveLoc[5](loc2: Option<address>)
	26: Ret
}

public add_approval<Ty0, Ty1: drop>(Arg0: Ty1, Arg1: &mut ActionRequest<Ty0>, Arg2: &mut TxContext) {
B0:
	0: MoveLoc[1](Arg1: &mut ActionRequest<Ty0>)
	1: MutBorrowFieldGeneric[5](ActionRequest.approvals: VecSet<TypeName>)
	2: Call type_name::get<Ty1>(): TypeName
	3: Call vec_set::insert<TypeName>(&mut VecSet<TypeName>, TypeName)
	4: Ret
}

public add_rule_config<Ty0, Ty1: drop, Ty2: store>(Arg0: Ty1, Arg1: &mut TokenPolicy<Ty0>, Arg2: &TokenPolicyCap<Ty0>, Arg3: Ty2, Arg4: &mut TxContext) {
B0:
	0: CopyLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	3: MoveLoc[2](Arg2: &TokenPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	10: Pop
	11: LdConst[2](u64: 2)
	12: Abort
B3:
	13: MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	14: MutBorrowFieldGeneric[7](TokenPolicy.id: UID)
	15: Call key<Ty1>(): RuleKey<Ty1>
	16: MoveLoc[3](Arg3: Ty2)
	17: Call dynamic_field::add<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>, Ty2)
	18: Ret
}

public rule_config<Ty0, Ty1: drop, Ty2: store>(Arg0: Ty1, Arg1: &TokenPolicy<Ty0>): &Ty2 {
B0:
	0: CopyLoc[1](Arg1: &TokenPolicy<Ty0>)
	1: Call has_rule_config_with_type<Ty0, Ty1, Ty2>(&TokenPolicy<Ty0>): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[1](Arg1: &TokenPolicy<Ty0>)
	5: Pop
	6: LdConst[6](u64: 6)
	7: Abort
B3:
	8: MoveLoc[1](Arg1: &TokenPolicy<Ty0>)
	9: ImmBorrowFieldGeneric[7](TokenPolicy.id: UID)
	10: Call key<Ty1>(): RuleKey<Ty1>
	11: Call dynamic_field::borrow<RuleKey<Ty1>, Ty2>(&UID, RuleKey<Ty1>): &Ty2
	12: Ret
}

public rule_config_mut<Ty0, Ty1: drop, Ty2: store>(Arg0: Ty1, Arg1: &mut TokenPolicy<Ty0>, Arg2: &TokenPolicyCap<Ty0>): &mut Ty2 {
B0:
	0: CopyLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call has_rule_config_with_type<Ty0, Ty1, Ty2>(&TokenPolicy<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	6: Pop
	7: MoveLoc[2](Arg2: &TokenPolicyCap<Ty0>)
	8: Pop
	9: LdConst[6](u64: 6)
	10: Abort
B3:
	11: CopyLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	12: FreezeRef
	13: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	14: MoveLoc[2](Arg2: &TokenPolicyCap<Ty0>)
	15: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	16: ReadRef
	17: Eq
	18: BrFalse(20)
B4:
	19: Branch(24)
B5:
	20: MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	21: Pop
	22: LdConst[2](u64: 2)
	23: Abort
B6:
	24: MoveLoc[1](Arg1: &mut TokenPolicy<Ty0>)
	25: MutBorrowFieldGeneric[7](TokenPolicy.id: UID)
	26: Call key<Ty1>(): RuleKey<Ty1>
	27: Call dynamic_field::borrow_mut<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>): &mut Ty2
	28: Ret
}

public remove_rule_config<Ty0, Ty1, Ty2: store>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: &mut TxContext): Ty2 {
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call has_rule_config_with_type<Ty0, Ty1, Ty2>(&TokenPolicy<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(11)
B2:
	5: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	6: Pop
	7: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	8: Pop
	9: LdConst[6](u64: 6)
	10: Abort
B3:
	11: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	12: FreezeRef
	13: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	14: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	15: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	16: ReadRef
	17: Eq
	18: BrFalse(20)
B4:
	19: Branch(24)
B5:
	20: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	21: Pop
	22: LdConst[2](u64: 2)
	23: Abort
B6:
	24: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	25: MutBorrowFieldGeneric[7](TokenPolicy.id: UID)
	26: Call key<Ty1>(): RuleKey<Ty1>
	27: Call dynamic_field::remove<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>): Ty2
	28: Ret
}

public has_rule_config<Ty0, Ty1>(Arg0: &TokenPolicy<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[7](TokenPolicy.id: UID)
	2: Call key<Ty1>(): RuleKey<Ty1>
	3: Call dynamic_field::exists_<RuleKey<Ty1>>(&UID, RuleKey<Ty1>): bool
	4: Ret
}

public has_rule_config_with_type<Ty0, Ty1, Ty2: store>(Arg0: &TokenPolicy<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[7](TokenPolicy.id: UID)
	2: Call key<Ty1>(): RuleKey<Ty1>
	3: Call dynamic_field::exists_with_type<RuleKey<Ty1>, Ty2>(&UID, RuleKey<Ty1>): bool
	4: Ret
}

public allow<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	3: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	10: Pop
	11: LdConst[2](u64: 2)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	14: MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	15: MoveLoc[2](Arg2: String)
	16: Call vec_set::empty<TypeName>(): VecSet<TypeName>
	17: Call vec_map::insert<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, String, VecSet<TypeName>)
	18: Ret
}

public disallow<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	3: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	10: Pop
	11: LdConst[2](u64: 2)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	14: MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	15: ImmBorrowLoc[2](Arg2: String)
	16: Call vec_map::remove<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, &String): String * VecSet<TypeName>
	17: Pop
	18: Pop
	19: Ret
}

public add_rule_for_action<Ty0, Ty1: drop>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	3: CopyLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(17)
B2:
	9: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	10: Pop
	11: MoveLoc[3](Arg3: &mut TxContext)
	12: Pop
	13: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	14: Pop
	15: LdConst[2](u64: 2)
	16: Abort
B3:
	17: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	18: ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	19: ImmBorrowLoc[2](Arg2: String)
	20: Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool
	21: Not
	22: BrFalse(29)
B4:
	23: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	24: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	25: CopyLoc[2](Arg2: String)
	26: MoveLoc[3](Arg3: &mut TxContext)
	27: Call allow<Ty0>(&mut TokenPolicy<Ty0>, &TokenPolicyCap<Ty0>, String, &mut TxContext)
	28: Branch(33)
B5:
	29: MoveLoc[3](Arg3: &mut TxContext)
	30: Pop
	31: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	32: Pop
B6:
	33: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	34: MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	35: ImmBorrowLoc[2](Arg2: String)
	36: Call vec_map::get_mut<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, &String): &mut VecSet<TypeName>
	37: Call type_name::get<Ty1>(): TypeName
	38: Call vec_set::insert<TypeName>(&mut VecSet<TypeName>, TypeName)
	39: Ret
}

public remove_rule_for_action<Ty0, Ty1: drop>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &TokenPolicyCap<Ty0>, Arg2: String, Arg3: &mut TxContext) {
L4:	loc0: TypeName
L5:	loc1: &mut VecSet<TypeName>
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TokenPolicy<Ty0>>(&TokenPolicy<Ty0>): ID
	3: MoveLoc[1](Arg1: &TokenPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[6](TokenPolicyCap.for: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	10: Pop
	11: LdConst[2](u64: 2)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	14: MutBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	15: ImmBorrowLoc[2](Arg2: String)
	16: Call vec_map::get_mut<String, VecSet<TypeName>>(&mut VecMap<String, VecSet<TypeName>>, &String): &mut VecSet<TypeName>
	17: StLoc[5](loc1: &mut VecSet<TypeName>)
	18: Call type_name::get<Ty1>(): TypeName
	19: StLoc[4](loc0: TypeName)
	20: MoveLoc[5](loc1: &mut VecSet<TypeName>)
	21: ImmBorrowLoc[4](loc0: TypeName)
	22: Call vec_set::remove<TypeName>(&mut VecSet<TypeName>, &TypeName)
	23: Ret
}

public mint<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: u64, Arg2: &mut TxContext): Token<Ty0> {
L3:	loc0: Balance<Ty0>
B0:
	0: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	1: Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>
	2: MoveLoc[1](Arg1: u64)
	3: Call balance::increase_supply<Ty0>(&mut Supply<Ty0>, u64): Balance<Ty0>
	4: StLoc[3](loc0: Balance<Ty0>)
	5: MoveLoc[2](Arg2: &mut TxContext)
	6: Call object::new(&mut TxContext): UID
	7: MoveLoc[3](loc0: Balance<Ty0>)
	8: PackGeneric[3](Token<Ty0>)
	9: Ret
}

public burn<Ty0>(Arg0: &mut TreasuryCap<Ty0>, Arg1: Token<Ty0>) {
L2:	loc0: Balance<Ty0>
L3:	loc1: UID
B0:
	0: MoveLoc[1](Arg1: Token<Ty0>)
	1: UnpackGeneric[3](Token<Ty0>)
	2: StLoc[2](loc0: Balance<Ty0>)
	3: StLoc[3](loc1: UID)
	4: MoveLoc[0](Arg0: &mut TreasuryCap<Ty0>)
	5: Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>
	6: MoveLoc[2](loc0: Balance<Ty0>)
	7: Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64
	8: Pop
	9: MoveLoc[3](loc1: UID)
	10: Call object::delete(UID)
	11: Ret
}

public flush<Ty0>(Arg0: &mut TokenPolicy<Ty0>, Arg1: &mut TreasuryCap<Ty0>, Arg2: &mut TxContext): u64 {
L3:	loc0: u64
L4:	loc1: Balance<Ty0>
B0:
	0: CopyLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: StLoc[3](loc0: u64)
	4: MoveLoc[0](Arg0: &mut TokenPolicy<Ty0>)
	5: MutBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)
	6: MoveLoc[3](loc0: u64)
	7: Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
	8: StLoc[4](loc1: Balance<Ty0>)
	9: MoveLoc[1](Arg1: &mut TreasuryCap<Ty0>)
	10: Call coin::supply_mut<Ty0>(&mut TreasuryCap<Ty0>): &mut Supply<Ty0>
	11: MoveLoc[4](loc1: Balance<Ty0>)
	12: Call balance::decrease_supply<Ty0>(&mut Supply<Ty0>, Balance<Ty0>): u64
	13: Ret
}

public is_allowed<Ty0>(Arg0: &TokenPolicy<Ty0>, Arg1: &String): bool {
B0:
	0: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	2: MoveLoc[1](Arg1: &String)
	3: Call vec_map::contains<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): bool
	4: Ret
}

public rules<Ty0>(Arg0: &TokenPolicy<Ty0>, Arg1: &String): VecSet<TypeName> {
B0:
	0: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[2](TokenPolicy.rules: VecMap<String, VecSet<TypeName>>)
	2: MoveLoc[1](Arg1: &String)
	3: Call vec_map::get<String, VecSet<TypeName>>(&VecMap<String, VecSet<TypeName>>, &String): &VecSet<TypeName>
	4: ReadRef
	5: Ret
}

public spent_balance<Ty0>(Arg0: &TokenPolicy<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &TokenPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[4](TokenPolicy.spent_balance: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: Ret
}

public value<Ty0>(Arg0: &Token<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &Token<Ty0>)
	1: ImmBorrowFieldGeneric[0](Token.balance: Balance<Ty0>)
	2: Call balance::value<Ty0>(&Balance<Ty0>): u64
	3: Ret
}

public transfer_action(): String {
B0:
	0: LdConst[9](vector<u8>: "tra..)
	1: Call string::utf8(vector<u8>): String
	2: Ret
}

public spend_action(): String {
B0:
	0: LdConst[8](vector<u8>: "spe..)
	1: Call string::utf8(vector<u8>): String
	2: Ret
}

public to_coin_action(): String {
B0:
	0: LdConst[10](vector<u8>: "to_..)
	1: Call string::utf8(vector<u8>): String
	2: Ret
}

public from_coin_action(): String {
B0:
	0: LdConst[11](vector<u8>: "fro..)
	1: Call string::utf8(vector<u8>): String
	2: Ret
}

public action<Ty0>(Arg0: &ActionRequest<Ty0>): String {
B0:
	0: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[3](ActionRequest.name: String)
	2: ReadRef
	3: Ret
}

public amount<Ty0>(Arg0: &ActionRequest<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[8](ActionRequest.amount: u64)
	2: ReadRef
	3: Ret
}

public sender<Ty0>(Arg0: &ActionRequest<Ty0>): address {
B0:
	0: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[9](ActionRequest.sender: address)
	2: ReadRef
	3: Ret
}

public recipient<Ty0>(Arg0: &ActionRequest<Ty0>): Option<address> {
B0:
	0: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[10](ActionRequest.recipient: Option<address>)
	2: ReadRef
	3: Ret
}

public approvals<Ty0>(Arg0: &ActionRequest<Ty0>): VecSet<TypeName> {
B0:
	0: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[5](ActionRequest.approvals: VecSet<TypeName>)
	2: ReadRef
	3: Ret
}

public spent<Ty0>(Arg0: &ActionRequest<Ty0>): Option<u64> {
L1:	loc0: Option<u64>
B0:
	0: CopyLoc[0](Arg0: &ActionRequest<Ty0>)
	1: ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)
	2: Call option::is_some<Balance<Ty0>>(&Option<Balance<Ty0>>): bool
	3: BrFalse(11)
B1:
	4: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	5: ImmBorrowFieldGeneric[1](ActionRequest.spent_balance: Option<Balance<Ty0>>)
	6: Call option::borrow<Balance<Ty0>>(&Option<Balance<Ty0>>): &Balance<Ty0>
	7: Call balance::value<Ty0>(&Balance<Ty0>): u64
	8: Call option::some<u64>(u64): Option<u64>
	9: StLoc[1](loc0: Option<u64>)
	10: Branch(15)
B2:
	11: MoveLoc[0](Arg0: &ActionRequest<Ty0>)
	12: Pop
	13: Call option::none<u64>(): Option<u64>
	14: StLoc[1](loc0: Option<u64>)
B3:
	15: MoveLoc[1](loc0: Option<u64>)
	16: Ret
}

key<Ty0>(): RuleKey<Ty0> {
B0:
	0: LdTrue
	1: PackGeneric[5](RuleKey<Ty0>)
	2: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
	6 => u64: 6
	7 => u64: 7
	8 => vector<u8>: "spend" // interpreted as UTF8 string
	9 => vector<u8>: "transfer" // interpreted as UTF8 string
	10 => vector<u8>: "to_coin" // interpreted as UTF8 string
	11 => vector<u8>: "from_coin" // interpreted as UTF8 string
]
}

// Move bytecode v6
module 2.transfer {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::party;

struct Receiving<phantom Ty0: key> has drop {
	id: ID,
	version: u64
}

public transfer<Ty0: key>(Arg0: Ty0, Arg1: address) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: MoveLoc[1](Arg1: address)
	2: Call transfer_impl<Ty0>(Ty0, address)
	3: Ret
}

public public_transfer<Ty0: store + key>(Arg0: Ty0, Arg1: address) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: MoveLoc[1](Arg1: address)
	2: Call transfer_impl<Ty0>(Ty0, address)
	3: Ret
}

public party_transfer<Ty0: key>(Arg0: Ty0, Arg1: Party) {
L2:	loc0: vector<address>
L3:	loc1: u64
L4:	loc2: vector<u64>
B0:
	0: ImmBorrowLoc[1](Arg1: Party)
	1: Call party::is_single_owner(&Party): bool
	2: BrFalse(4)
B1:
	3: Branch(6)
B2:
	4: LdU64(13836747253035171847)
	5: Abort
B3:
	6: MoveLoc[1](Arg1: Party)
	7: Call party::into_native(Party): u64 * vector<address> * vector<u64>
	8: StLoc[4](loc2: vector<u64>)
	9: StLoc[2](loc0: vector<address>)
	10: StLoc[3](loc1: u64)
	11: MoveLoc[0](Arg0: Ty0)
	12: MoveLoc[3](loc1: u64)
	13: MoveLoc[2](loc0: vector<address>)
	14: MoveLoc[4](loc2: vector<u64>)
	15: Call party_transfer_impl<Ty0>(Ty0, u64, vector<address>, vector<u64>)
	16: Ret
}

public public_party_transfer<Ty0: store + key>(Arg0: Ty0, Arg1: Party) {
L2:	loc0: vector<address>
L3:	loc1: u64
L4:	loc2: vector<u64>
B0:
	0: ImmBorrowLoc[1](Arg1: Party)
	1: Call party::is_single_owner(&Party): bool
	2: BrFalse(4)
B1:
	3: Branch(6)
B2:
	4: LdU64(13836747321754648583)
	5: Abort
B3:
	6: MoveLoc[1](Arg1: Party)
	7: Call party::into_native(Party): u64 * vector<address> * vector<u64>
	8: StLoc[4](loc2: vector<u64>)
	9: StLoc[2](loc0: vector<address>)
	10: StLoc[3](loc1: u64)
	11: MoveLoc[0](Arg0: Ty0)
	12: MoveLoc[3](loc1: u64)
	13: MoveLoc[2](loc0: vector<address>)
	14: MoveLoc[4](loc2: vector<u64>)
	15: Call party_transfer_impl<Ty0>(Ty0, u64, vector<address>, vector<u64>)
	16: Ret
}

public freeze_object<Ty0: key>(Arg0: Ty0) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: Call freeze_object_impl<Ty0>(Ty0)
	2: Ret
}

public public_freeze_object<Ty0: store + key>(Arg0: Ty0) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: Call freeze_object_impl<Ty0>(Ty0)
	2: Ret
}

public share_object<Ty0: key>(Arg0: Ty0) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: Call share_object_impl<Ty0>(Ty0)
	2: Ret
}

public public_share_object<Ty0: store + key>(Arg0: Ty0) {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: Call share_object_impl<Ty0>(Ty0)
	2: Ret
}

public receive<Ty0: key>(Arg0: &mut UID, Arg1: Receiving<Ty0>): Ty0 {
L2:	loc0: ID
L3:	loc1: u64
B0:
	0: MoveLoc[1](Arg1: Receiving<Ty0>)
	1: UnpackGeneric[0](Receiving<Ty0>)
	2: StLoc[3](loc1: u64)
	3: StLoc[2](loc0: ID)
	4: MoveLoc[0](Arg0: &mut UID)
	5: FreezeRef
	6: Call object::uid_to_address(&UID): address
	7: MoveLoc[2](loc0: ID)
	8: MoveLoc[3](loc1: u64)
	9: Call receive_impl<Ty0>(address, ID, u64): Ty0
	10: Ret
}

public public_receive<Ty0: store + key>(Arg0: &mut UID, Arg1: Receiving<Ty0>): Ty0 {
L2:	loc0: ID
L3:	loc1: u64
B0:
	0: MoveLoc[1](Arg1: Receiving<Ty0>)
	1: UnpackGeneric[0](Receiving<Ty0>)
	2: StLoc[3](loc1: u64)
	3: StLoc[2](loc0: ID)
	4: MoveLoc[0](Arg0: &mut UID)
	5: FreezeRef
	6: Call object::uid_to_address(&UID): address
	7: MoveLoc[2](loc0: ID)
	8: MoveLoc[3](loc1: u64)
	9: Call receive_impl<Ty0>(address, ID, u64): Ty0
	10: Ret
}

public receiving_object_id<Ty0: key>(Arg0: &Receiving<Ty0>): ID {
B0:
	0: MoveLoc[0](Arg0: &Receiving<Ty0>)
	1: ImmBorrowFieldGeneric[0](Receiving.id: ID)
	2: ReadRef
	3: Ret
}

native public(friend) freeze_object_impl<Ty0: key>(Arg0: Ty0);

native public(friend) share_object_impl<Ty0: key>(Arg0: Ty0);

native public(friend) party_transfer_impl<Ty0: key>(Arg0: Ty0, Arg1: u64, Arg2: vector<address>, Arg3: vector<u64>);

native public(friend) transfer_impl<Ty0: key>(Arg0: Ty0, Arg1: address);

native receive_impl<Ty0: key>(Arg0: address, Arg1: ID, Arg2: u64): Ty0;

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
	6 => vector<u8>: "EInvalidPartyPermissions" // interpreted as UTF8 string
	7 => vector<u8>: "Party transfer is currently limited to one party." // interpreted as UTF8 string
]
}

// Move bytecode v6
module 2.transfer_policy {
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::safe;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;

struct TransferRequest<phantom Ty0> {
	item: ID,
	paid: u64,
	from: ID,
	receipts: VecSet<TypeName>
}

struct TransferPolicy<phantom Ty0> has store, key {
	id: UID,
	balance: Balance<SAFE>,
	rules: VecSet<TypeName>
}

struct TransferPolicyCap<phantom Ty0> has store, key {
	id: UID,
	policy_id: ID
}

struct TransferPolicyCreated<phantom Ty0> has copy, drop {
	id: ID
}

struct TransferPolicyDestroyed<phantom Ty0> has copy, drop {
	id: ID
}

struct RuleKey<phantom Ty0: drop> has copy, drop, store {
	dummy_field: bool
}

public new_request<Ty0>(Arg0: ID, Arg1: u64, Arg2: ID): TransferRequest<Ty0> {
B0:
	0: MoveLoc[0](Arg0: ID)
	1: MoveLoc[1](Arg1: u64)
	2: MoveLoc[2](Arg2: ID)
	3: Call vec_set::empty<TypeName>(): VecSet<TypeName>
	4: PackGeneric[0](TransferRequest<Ty0>)
	5: Ret
}

public new<Ty0>(Arg0: &Publisher, Arg1: &mut TxContext): TransferPolicy<Ty0> * TransferPolicyCap<Ty0> {
L2:	loc0: UID
L3:	loc1: VecSet<TypeName>
L4:	loc2: Balance<SAFE>
L5:	loc3: UID
L6:	loc4: ID
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: Call package::from_package<Ty0>(&Publisher): bool
	2: BrFalse(4)
B1:
	3: Branch(8)
B2:
	4: MoveLoc[1](Arg1: &mut TxContext)
	5: Pop
	6: LdU64(0)
	7: Abort
B3:
	8: CopyLoc[1](Arg1: &mut TxContext)
	9: Call object::new(&mut TxContext): UID
	10: StLoc[5](loc3: UID)
	11: ImmBorrowLoc[5](loc3: UID)
	12: Call object::uid_to_inner(&UID): ID
	13: StLoc[6](loc4: ID)
	14: CopyLoc[6](loc4: ID)
	15: PackGeneric[1](TransferPolicyCreated<Ty0>)
	16: Call event::emit<TransferPolicyCreated<Ty0>>(TransferPolicyCreated<Ty0>)
	17: MoveLoc[5](loc3: UID)
	18: StLoc[2](loc0: UID)
	19: Call vec_set::empty<TypeName>(): VecSet<TypeName>
	20: StLoc[3](loc1: VecSet<TypeName>)
	21: Call balance::zero<SAFE>(): Balance<SAFE>
	22: StLoc[4](loc2: Balance<SAFE>)
	23: MoveLoc[2](loc0: UID)
	24: MoveLoc[4](loc2: Balance<SAFE>)
	25: MoveLoc[3](loc1: VecSet<TypeName>)
	26: PackGeneric[2](TransferPolicy<Ty0>)
	27: MoveLoc[1](Arg1: &mut TxContext)
	28: Call object::new(&mut TxContext): UID
	29: MoveLoc[6](loc4: ID)
	30: PackGeneric[3](TransferPolicyCap<Ty0>)
	31: Ret
}

entry default<Ty0>(Arg0: &Publisher, Arg1: &mut TxContext) {
L2:	loc0: TransferPolicyCap<Ty0>
B0:
	0: MoveLoc[0](Arg0: &Publisher)
	1: CopyLoc[1](Arg1: &mut TxContext)
	2: Call new<Ty0>(&Publisher, &mut TxContext): TransferPolicy<Ty0> * TransferPolicyCap<Ty0>
	3: StLoc[2](loc0: TransferPolicyCap<Ty0>)
	4: Call transfer::share_object<TransferPolicy<Ty0>>(TransferPolicy<Ty0>)
	5: MoveLoc[2](loc0: TransferPolicyCap<Ty0>)
	6: MoveLoc[1](Arg1: &mut TxContext)
	7: FreezeRef
	8: Call tx_context::sender(&TxContext): address
	9: Call transfer::transfer<TransferPolicyCap<Ty0>>(TransferPolicyCap<Ty0>, address)
	10: Ret
}

public withdraw<Ty0>(Arg0: &mut TransferPolicy<Ty0>, Arg1: &TransferPolicyCap<Ty0>, Arg2: Option<u64>, Arg3: &mut TxContext): Coin<SAFE> {
L4:	loc0: u64
L5:	loc1: u64
L6:	loc2: u64
B0:
	0: CopyLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TransferPolicy<Ty0>>(&TransferPolicy<Ty0>): ID
	3: MoveLoc[1](Arg1: &TransferPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[0](TransferPolicyCap.policy_id: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(15)
B2:
	9: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	10: Pop
	11: MoveLoc[3](Arg3: &mut TxContext)
	12: Pop
	13: LdConst[4](u64: 4)
	14: Abort
B3:
	15: ImmBorrowLoc[2](Arg2: Option<u64>)
	16: Call option::is_some<u64>(&Option<u64>): bool
	17: BrFalse(37)
B4:
	18: MoveLoc[2](Arg2: Option<u64>)
	19: Call option::destroy_some<u64>(Option<u64>): u64
	20: StLoc[6](loc2: u64)
	21: CopyLoc[6](loc2: u64)
	22: CopyLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	23: ImmBorrowFieldGeneric[1](TransferPolicy.balance: Balance<SAFE>)
	24: Call balance::value<SAFE>(&Balance<SAFE>): u64
	25: Le
	26: BrFalse(28)
B5:
	27: Branch(34)
B6:
	28: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	29: Pop
	30: MoveLoc[3](Arg3: &mut TxContext)
	31: Pop
	32: LdConst[5](u64: 5)
	33: Abort
B7:
	34: MoveLoc[6](loc2: u64)
	35: StLoc[4](loc0: u64)
	36: Branch(41)
B8:
	37: CopyLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	38: ImmBorrowFieldGeneric[1](TransferPolicy.balance: Balance<SAFE>)
	39: Call balance::value<SAFE>(&Balance<SAFE>): u64
	40: StLoc[4](loc0: u64)
B9:
	41: MoveLoc[4](loc0: u64)
	42: StLoc[5](loc1: u64)
	43: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	44: MutBorrowFieldGeneric[1](TransferPolicy.balance: Balance<SAFE>)
	45: MoveLoc[5](loc1: u64)
	46: MoveLoc[3](Arg3: &mut TxContext)
	47: Call coin::take<SAFE>(&mut Balance<SAFE>, u64, &mut TxContext): Coin<SAFE>
	48: Ret
}

public destroy_and_withdraw<Ty0>(Arg0: TransferPolicy<Ty0>, Arg1: TransferPolicyCap<Ty0>, Arg2: &mut TxContext): Coin<SAFE> {
L3:	loc0: Balance<SAFE>
L4:	loc1: UID
L5:	loc2: ID
B0:
	0: ImmBorrowLoc[0](Arg0: TransferPolicy<Ty0>)
	1: Call object::id<TransferPolicy<Ty0>>(&TransferPolicy<Ty0>): ID
	2: ImmBorrowLoc[1](Arg1: TransferPolicyCap<Ty0>)
	3: ImmBorrowFieldGeneric[0](TransferPolicyCap.policy_id: ID)
	4: ReadRef
	5: Eq
	6: BrFalse(8)
B1:
	7: Branch(12)
B2:
	8: MoveLoc[2](Arg2: &mut TxContext)
	9: Pop
	10: LdConst[4](u64: 4)
	11: Abort
B3:
	12: MoveLoc[1](Arg1: TransferPolicyCap<Ty0>)
	13: UnpackGeneric[3](TransferPolicyCap<Ty0>)
	14: StLoc[5](loc2: ID)
	15: StLoc[4](loc1: UID)
	16: MoveLoc[0](Arg0: TransferPolicy<Ty0>)
	17: UnpackGeneric[2](TransferPolicy<Ty0>)
	18: Pop
	19: StLoc[3](loc0: Balance<SAFE>)
	20: Call object::delete(UID)
	21: MoveLoc[4](loc1: UID)
	22: Call object::delete(UID)
	23: MoveLoc[5](loc2: ID)
	24: PackGeneric[4](TransferPolicyDestroyed<Ty0>)
	25: Call event::emit<TransferPolicyDestroyed<Ty0>>(TransferPolicyDestroyed<Ty0>)
	26: MoveLoc[3](loc0: Balance<SAFE>)
	27: MoveLoc[2](Arg2: &mut TxContext)
	28: Call coin::from_balance<SAFE>(Balance<SAFE>, &mut TxContext): Coin<SAFE>
	29: Ret
}

public confirm_request<Ty0>(Arg0: &TransferPolicy<Ty0>, Arg1: TransferRequest<Ty0>): ID * u64 * ID {
L2:	loc0: vector<TypeName>
L3:	loc1: ID
L4:	loc2: ID
L5:	loc3: u64
L6:	loc4: VecSet<TypeName>
L7:	loc5: TypeName
L8:	loc6: u64
B0:
	0: MoveLoc[1](Arg1: TransferRequest<Ty0>)
	1: UnpackGeneric[0](TransferRequest<Ty0>)
	2: StLoc[6](loc4: VecSet<TypeName>)
	3: StLoc[3](loc1: ID)
	4: StLoc[5](loc3: u64)
	5: StLoc[4](loc2: ID)
	6: MoveLoc[6](loc4: VecSet<TypeName>)
	7: Call vec_set::into_keys<TypeName>(VecSet<TypeName>): vector<TypeName>
	8: StLoc[2](loc0: vector<TypeName>)
	9: ImmBorrowLoc[2](loc0: vector<TypeName>)
	10: VecLen(23)
	11: StLoc[8](loc6: u64)
	12: CopyLoc[8](loc6: u64)
	13: CopyLoc[0](Arg0: &TransferPolicy<Ty0>)
	14: ImmBorrowFieldGeneric[2](TransferPolicy.rules: VecSet<TypeName>)
	15: Call vec_set::size<TypeName>(&VecSet<TypeName>): u64
	16: Eq
	17: BrFalse(19)
B1:
	18: Branch(23)
B2:
	19: MoveLoc[0](Arg0: &TransferPolicy<Ty0>)
	20: Pop
	21: LdConst[0](u64: 0)
	22: Abort
B3:
	23: CopyLoc[8](loc6: u64)
	24: LdU64(0)
	25: Gt
	26: BrFalse(45)
B4:
	27: MutBorrowLoc[2](loc0: vector<TypeName>)
	28: VecPopBack(23)
	29: StLoc[7](loc5: TypeName)
	30: CopyLoc[0](Arg0: &TransferPolicy<Ty0>)
	31: ImmBorrowFieldGeneric[2](TransferPolicy.rules: VecSet<TypeName>)
	32: ImmBorrowLoc[7](loc5: TypeName)
	33: Call vec_set::contains<TypeName>(&VecSet<TypeName>, &TypeName): bool
	34: BrFalse(36)
B5:
	35: Branch(40)
B6:
	36: MoveLoc[0](Arg0: &TransferPolicy<Ty0>)
	37: Pop
	38: LdConst[1](u64: 1)
	39: Abort
B7:
	40: MoveLoc[8](loc6: u64)
	41: LdU64(1)
	42: Sub
	43: StLoc[8](loc6: u64)
	44: Branch(23)
B8:
	45: MoveLoc[0](Arg0: &TransferPolicy<Ty0>)
	46: Pop
	47: MoveLoc[4](loc2: ID)
	48: MoveLoc[5](loc3: u64)
	49: MoveLoc[3](loc1: ID)
	50: Ret
}

public add_rule<Ty0, Ty1: drop, Ty2: drop + store>(Arg0: Ty1, Arg1: &mut TransferPolicy<Ty0>, Arg2: &TransferPolicyCap<Ty0>, Arg3: Ty2) {
B0:
	0: CopyLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TransferPolicy<Ty0>>(&TransferPolicy<Ty0>): ID
	3: MoveLoc[2](Arg2: &TransferPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[0](TransferPolicyCap.policy_id: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	10: Pop
	11: LdConst[4](u64: 4)
	12: Abort
B3:
	13: CopyLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	14: FreezeRef
	15: Call has_rule<Ty0, Ty1>(&TransferPolicy<Ty0>): bool
	16: Not
	17: BrFalse(19)
B4:
	18: Branch(23)
B5:
	19: MoveLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	20: Pop
	21: LdConst[3](u64: 3)
	22: Abort
B6:
	23: CopyLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	24: MutBorrowFieldGeneric[3](TransferPolicy.id: UID)
	25: LdFalse
	26: PackGeneric[5](RuleKey<Ty1>)
	27: MoveLoc[3](Arg3: Ty2)
	28: Call dynamic_field::add<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>, Ty2)
	29: MoveLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	30: MutBorrowFieldGeneric[2](TransferPolicy.rules: VecSet<TypeName>)
	31: Call type_name::get<Ty1>(): TypeName
	32: Call vec_set::insert<TypeName>(&mut VecSet<TypeName>, TypeName)
	33: Ret
}

public get_rule<Ty0, Ty1: drop, Ty2: drop + store>(Arg0: Ty1, Arg1: &TransferPolicy<Ty0>): &Ty2 {
B0:
	0: MoveLoc[1](Arg1: &TransferPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[3](TransferPolicy.id: UID)
	2: LdFalse
	3: PackGeneric[5](RuleKey<Ty1>)
	4: Call dynamic_field::borrow<RuleKey<Ty1>, Ty2>(&UID, RuleKey<Ty1>): &Ty2
	5: Ret
}

public add_to_balance<Ty0, Ty1: drop>(Arg0: Ty1, Arg1: &mut TransferPolicy<Ty0>, Arg2: Coin<SAFE>) {
B0:
	0: CopyLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	1: FreezeRef
	2: Call has_rule<Ty0, Ty1>(&TransferPolicy<Ty0>): bool
	3: BrFalse(5)
B1:
	4: Branch(9)
B2:
	5: MoveLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	6: Pop
	7: LdConst[2](u64: 2)
	8: Abort
B3:
	9: MoveLoc[1](Arg1: &mut TransferPolicy<Ty0>)
	10: MutBorrowFieldGeneric[1](TransferPolicy.balance: Balance<SAFE>)
	11: MoveLoc[2](Arg2: Coin<SAFE>)
	12: Call coin::put<SAFE>(&mut Balance<SAFE>, Coin<SAFE>)
	13: Ret
}

public add_receipt<Ty0, Ty1: drop>(Arg0: Ty1, Arg1: &mut TransferRequest<Ty0>) {
B0:
	0: MoveLoc[1](Arg1: &mut TransferRequest<Ty0>)
	1: MutBorrowFieldGeneric[4](TransferRequest.receipts: VecSet<TypeName>)
	2: Call type_name::get<Ty1>(): TypeName
	3: Call vec_set::insert<TypeName>(&mut VecSet<TypeName>, TypeName)
	4: Ret
}

public has_rule<Ty0, Ty1: drop>(Arg0: &TransferPolicy<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &TransferPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[3](TransferPolicy.id: UID)
	2: LdFalse
	3: PackGeneric[5](RuleKey<Ty1>)
	4: Call dynamic_field::exists_<RuleKey<Ty1>>(&UID, RuleKey<Ty1>): bool
	5: Ret
}

public remove_rule<Ty0, Ty1: drop, Ty2: drop + store>(Arg0: &mut TransferPolicy<Ty0>, Arg1: &TransferPolicyCap<Ty0>) {
L2:	loc0: TypeName
L3:	loc1: &mut VecSet<TypeName>
B0:
	0: CopyLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TransferPolicy<Ty0>>(&TransferPolicy<Ty0>): ID
	3: MoveLoc[1](Arg1: &TransferPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[0](TransferPolicyCap.policy_id: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	10: Pop
	11: LdConst[4](u64: 4)
	12: Abort
B3:
	13: CopyLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	14: MutBorrowFieldGeneric[3](TransferPolicy.id: UID)
	15: LdFalse
	16: PackGeneric[5](RuleKey<Ty1>)
	17: Call dynamic_field::remove<RuleKey<Ty1>, Ty2>(&mut UID, RuleKey<Ty1>): Ty2
	18: Pop
	19: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	20: MutBorrowFieldGeneric[2](TransferPolicy.rules: VecSet<TypeName>)
	21: StLoc[3](loc1: &mut VecSet<TypeName>)
	22: Call type_name::get<Ty1>(): TypeName
	23: StLoc[2](loc0: TypeName)
	24: MoveLoc[3](loc1: &mut VecSet<TypeName>)
	25: ImmBorrowLoc[2](loc0: TypeName)
	26: Call vec_set::remove<TypeName>(&mut VecSet<TypeName>, &TypeName)
	27: Ret
}

public uid<Ty0>(Arg0: &TransferPolicy<Ty0>): &UID {
B0:
	0: MoveLoc[0](Arg0: &TransferPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[3](TransferPolicy.id: UID)
	2: Ret
}

public uid_mut_as_owner<Ty0>(Arg0: &mut TransferPolicy<Ty0>, Arg1: &TransferPolicyCap<Ty0>): &mut UID {
B0:
	0: CopyLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	1: FreezeRef
	2: Call object::id<TransferPolicy<Ty0>>(&TransferPolicy<Ty0>): ID
	3: MoveLoc[1](Arg1: &TransferPolicyCap<Ty0>)
	4: ImmBorrowFieldGeneric[0](TransferPolicyCap.policy_id: ID)
	5: ReadRef
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	10: Pop
	11: LdConst[4](u64: 4)
	12: Abort
B3:
	13: MoveLoc[0](Arg0: &mut TransferPolicy<Ty0>)
	14: MutBorrowFieldGeneric[3](TransferPolicy.id: UID)
	15: Ret
}

public rules<Ty0>(Arg0: &TransferPolicy<Ty0>): &VecSet<TypeName> {
B0:
	0: MoveLoc[0](Arg0: &TransferPolicy<Ty0>)
	1: ImmBorrowFieldGeneric[2](TransferPolicy.rules: VecSet<TypeName>)
	2: Ret
}

public item<Ty0>(Arg0: &TransferRequest<Ty0>): ID {
B0:
	0: MoveLoc[0](Arg0: &TransferRequest<Ty0>)
	1: ImmBorrowFieldGeneric[5](TransferRequest.item: ID)
	2: ReadRef
	3: Ret
}

public paid<Ty0>(Arg0: &TransferRequest<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &TransferRequest<Ty0>)
	1: ImmBorrowFieldGeneric[6](TransferRequest.paid: u64)
	2: ReadRef
	3: Ret
}

public from<Ty0>(Arg0: &TransferRequest<Ty0>): ID {
B0:
	0: MoveLoc[0](Arg0: &TransferRequest<Ty0>)
	1: ImmBorrowFieldGeneric[7](TransferRequest.from: ID)
	2: ReadRef
	3: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
]
}

// Move bytecode v6
module 2.tx_context {
use 0000000000000000000000000000000000000000000000000000000000000001::option;

struct TxContext has drop {
	sender: address,
	tx_hash: vector<u8>,
	epoch: u64,
	epoch_timestamp_ms: u64,
	ids_created: u64
}

public sender(Arg0: &TxContext): address {
B0:
	0: Call native_sender(): address
	1: Ret
}

native native_sender(): address;

public digest(Arg0: &TxContext): &vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &TxContext)
	1: ImmBorrowField[0](TxContext.tx_hash: vector<u8>)
	2: Ret
}

public epoch(Arg0: &TxContext): u64 {
B0:
	0: Call native_epoch(): u64
	1: Ret
}

native native_epoch(): u64;

public epoch_timestamp_ms(Arg0: &TxContext): u64 {
B0:
	0: Call native_epoch_timestamp_ms(): u64
	1: Ret
}

native native_epoch_timestamp_ms(): u64;

public sponsor(Arg0: &TxContext): Option<address> {
B0:
	0: Call option_sponsor(): Option<address>
	1: Ret
}

public fresh_object_address(Arg0: &mut TxContext): address {
B0:
	0: Call fresh_id(): address
	1: Ret
}

native fresh_id(): address;

public reference_gas_price(Arg0: &TxContext): u64 {
B0:
	0: Call native_rgp(): u64
	1: Ret
}

native native_rgp(): u64;

public gas_price(Arg0: &TxContext): u64 {
B0:
	0: Call native_gas_price(): u64
	1: Ret
}

native native_gas_price(): u64;

native native_ids_created(): u64;

native native_gas_budget(): u64;

option_sponsor(): Option<address> {
L0:	loc0: Option<address>
L1:	loc1: vector<address>
B0:
	0: Call native_sponsor(): vector<address>
	1: StLoc[1](loc1: vector<address>)
	2: ImmBorrowLoc[1](loc1: vector<address>)
	3: VecLen(1)
	4: LdU64(0)
	5: Eq
	6: BrFalse(10)
B1:
	7: Call option::none<address>(): Option<address>
	8: StLoc[0](loc0: Option<address>)
	9: Branch(16)
B2:
	10: ImmBorrowLoc[1](loc1: vector<address>)
	11: LdU64(0)
	12: VecImmBorrow(1)
	13: ReadRef
	14: Call option::some<address>(address): Option<address>
	15: StLoc[0](loc0: Option<address>)
B3:
	16: MoveLoc[0](loc0: Option<address>)
	17: Ret
}

native native_sponsor(): vector<address>;

native derive_id(Arg0: vector<u8>, Arg1: u64): address;

}

// Move bytecode v6
module 2.types {

native public is_one_time_witness<Ty0: drop>(Arg0: &Ty0): bool;

}

// Move bytecode v6
module 2.url {
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;

struct Url has copy, drop, store {
	url: String
}

public new_unsafe(Arg0: String): Url {
B0:
	0: MoveLoc[0](Arg0: String)
	1: Pack[0](Url)
	2: Ret
}

public new_unsafe_from_bytes(Arg0: vector<u8>): Url {
B0:
	0: MoveLoc[0](Arg0: vector<u8>)
	1: Call ascii::string(vector<u8>): String
	2: Pack[0](Url)
	3: Ret
}

public inner_url(Arg0: &Url): String {
B0:
	0: MoveLoc[0](Arg0: &Url)
	1: ImmBorrowField[0](Url.url: String)
	2: ReadRef
	3: Ret
}

public update(Arg0: &mut Url, Arg1: String) {
B0:
	0: MoveLoc[1](Arg1: String)
	1: MoveLoc[0](Arg0: &mut Url)
	2: MutBorrowField[0](Url.url: String)
	3: WriteRef
	4: Ret
}

}

// Move bytecode v6
module 2.vdf {

public hash_to_input(Arg0: &vector<u8>): vector<u8> {
B0:
	0: MoveLoc[0](Arg0: &vector<u8>)
	1: Call hash_to_input_internal(&vector<u8>): vector<u8>
	2: Ret
}

native hash_to_input_internal(Arg0: &vector<u8>): vector<u8>;

public vdf_verify(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: u64): bool {
B0:
	0: MoveLoc[0](Arg0: &vector<u8>)
	1: MoveLoc[1](Arg1: &vector<u8>)
	2: MoveLoc[2](Arg2: &vector<u8>)
	3: MoveLoc[3](Arg3: u64)
	4: Call vdf_verify_internal(&vector<u8>, &vector<u8>, &vector<u8>, u64): bool
	5: Ret
}

native vdf_verify_internal(Arg0: &vector<u8>, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: u64): bool;

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.vec_map {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct VecMap<Ty0: copy, Ty1> has copy, drop, store {
	contents: vector<Entry<Ty0, Ty1>>
}

struct Entry<Ty0: copy, Ty1> has copy, drop, store {
	key: Ty0,
	value: Ty1
}

public empty<Ty0: copy, Ty1>(): VecMap<Ty0, Ty1> {
B0:
	0: VecPack(20, 0)
	1: PackGeneric[0](VecMap<Ty0, Ty1>)
	2: Ret
}

public insert<Ty0: copy, Ty1>(Arg0: &mut VecMap<Ty0, Ty1>, Arg1: Ty0, Arg2: Ty1) {
B0:
	0: CopyLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	1: FreezeRef
	2: ImmBorrowLoc[1](Arg1: Ty0)
	3: Call contains<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): bool
	4: Not
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	12: MutBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	13: MoveLoc[1](Arg1: Ty0)
	14: MoveLoc[2](Arg2: Ty1)
	15: PackGeneric[1](Entry<Ty0, Ty1>)
	16: VecPushBack(20)
	17: Ret
}

public remove<Ty0: copy, Ty1>(Arg0: &mut VecMap<Ty0, Ty1>, Arg1: &Ty0): Ty0 * Ty1 {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	1: FreezeRef
	2: MoveLoc[1](Arg1: &Ty0)
	3: Call get_idx<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): u64
	4: StLoc[2](loc0: u64)
	5: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	6: MutBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	7: MoveLoc[2](loc0: u64)
	8: Call vector::remove<Entry<Ty0, Ty1>>(&mut vector<Entry<Ty0, Ty1>>, u64): Entry<Ty0, Ty1>
	9: UnpackGeneric[1](Entry<Ty0, Ty1>)
	10: Ret
}

public pop<Ty0: copy, Ty1>(Arg0: &mut VecMap<Ty0, Ty1>): Ty0 * Ty1 {
B0:
	0: CopyLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	2: VecLen(20)
	3: LdU64(0)
	4: Neq
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	8: Pop
	9: LdConst[4](u64: 4)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	12: MutBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	13: VecPopBack(20)
	14: UnpackGeneric[1](Entry<Ty0, Ty1>)
	15: Ret
}

public get_mut<Ty0: copy, Ty1>(Arg0: &mut VecMap<Ty0, Ty1>, Arg1: &Ty0): &mut Ty1 {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	1: FreezeRef
	2: MoveLoc[1](Arg1: &Ty0)
	3: Call get_idx<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): u64
	4: StLoc[2](loc0: u64)
	5: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	6: MutBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	7: MoveLoc[2](loc0: u64)
	8: VecMutBorrow(20)
	9: MutBorrowFieldGeneric[1](Entry.value: Ty1)
	10: Ret
}

public get<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>, Arg1: &Ty0): &Ty1 {
L2:	loc0: u64
B0:
	0: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	1: MoveLoc[1](Arg1: &Ty0)
	2: Call get_idx<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): u64
	3: StLoc[2](loc0: u64)
	4: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	5: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	6: MoveLoc[2](loc0: u64)
	7: VecImmBorrow(20)
	8: ImmBorrowFieldGeneric[1](Entry.value: Ty1)
	9: Ret
}

public try_get<Ty0: copy, Ty1: copy>(Arg0: &VecMap<Ty0, Ty1>, Arg1: &Ty0): Option<Ty1> {
L2:	loc0: Option<Ty1>
B0:
	0: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	1: CopyLoc[1](Arg1: &Ty0)
	2: Call contains<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): bool
	3: BrFalse(11)
B1:
	4: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	5: MoveLoc[1](Arg1: &Ty0)
	6: Call get<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): &Ty1
	7: ReadRef
	8: Call option::some<Ty1>(Ty1): Option<Ty1>
	9: StLoc[2](loc0: Option<Ty1>)
	10: Branch(17)
B2:
	11: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	12: Pop
	13: MoveLoc[1](Arg1: &Ty0)
	14: Pop
	15: Call option::none<Ty1>(): Option<Ty1>
	16: StLoc[2](loc0: Option<Ty1>)
B3:
	17: MoveLoc[2](loc0: Option<Ty1>)
	18: Ret
}

public contains<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>, Arg1: &Ty0): bool {
L2:	loc0: Option<u64>
B0:
	0: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	1: MoveLoc[1](Arg1: &Ty0)
	2: Call get_idx_opt<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): Option<u64>
	3: StLoc[2](loc0: Option<u64>)
	4: ImmBorrowLoc[2](loc0: Option<u64>)
	5: Call option::is_some<u64>(&Option<u64>): bool
	6: Ret
}

public size<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>): u64 {
B0:
	0: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	1: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	2: VecLen(20)
	3: Ret
}

public is_empty<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>): bool {
B0:
	0: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	1: Call size<Ty0, Ty1>(&VecMap<Ty0, Ty1>): u64
	2: LdU64(0)
	3: Eq
	4: Ret
}

public destroy_empty<Ty0: copy, Ty1>(Arg0: VecMap<Ty0, Ty1>) {
L1:	loc0: vector<Entry<Ty0, Ty1>>
B0:
	0: MoveLoc[0](Arg0: VecMap<Ty0, Ty1>)
	1: UnpackGeneric[0](VecMap<Ty0, Ty1>)
	2: StLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	3: ImmBorrowLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	4: Call vector::is_empty<Entry<Ty0, Ty1>>(&vector<Entry<Ty0, Ty1>>): bool
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdConst[2](u64: 2)
	8: Abort
B3:
	9: MoveLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	10: VecUnpack(20, 0)
	11: Ret
}

public into_keys_values<Ty0: copy, Ty1>(Arg0: VecMap<Ty0, Ty1>): vector<Ty0> * vector<Ty1> {
L1:	loc0: vector<Entry<Ty0, Ty1>>
L2:	loc1: u64
L3:	loc2: Ty0
L4:	loc3: vector<Ty0>
L5:	loc4: u64
L6:	loc5: Ty1
L7:	loc6: vector<Ty1>
B0:
	0: MoveLoc[0](Arg0: VecMap<Ty0, Ty1>)
	1: UnpackGeneric[0](VecMap<Ty0, Ty1>)
	2: StLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	3: MutBorrowLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	4: Call vector::reverse<Entry<Ty0, Ty1>>(&mut vector<Entry<Ty0, Ty1>>)
	5: LdU64(0)
	6: StLoc[2](loc1: u64)
	7: ImmBorrowLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	8: VecLen(20)
	9: StLoc[5](loc4: u64)
	10: VecPack(22, 0)
	11: StLoc[4](loc3: vector<Ty0>)
	12: VecPack(23, 0)
	13: StLoc[7](loc6: vector<Ty1>)
B1:
	14: CopyLoc[2](loc1: u64)
	15: CopyLoc[5](loc4: u64)
	16: Lt
	17: BrFalse(35)
B2:
	18: Branch(19)
B3:
	19: MutBorrowLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	20: VecPopBack(20)
	21: UnpackGeneric[1](Entry<Ty0, Ty1>)
	22: StLoc[6](loc5: Ty1)
	23: StLoc[3](loc2: Ty0)
	24: MutBorrowLoc[4](loc3: vector<Ty0>)
	25: MoveLoc[3](loc2: Ty0)
	26: VecPushBack(22)
	27: MutBorrowLoc[7](loc6: vector<Ty1>)
	28: MoveLoc[6](loc5: Ty1)
	29: VecPushBack(23)
	30: MoveLoc[2](loc1: u64)
	31: LdU64(1)
	32: Add
	33: StLoc[2](loc1: u64)
	34: Branch(14)
B4:
	35: MoveLoc[1](loc0: vector<Entry<Ty0, Ty1>>)
	36: VecUnpack(20, 0)
	37: MoveLoc[4](loc3: vector<Ty0>)
	38: MoveLoc[7](loc6: vector<Ty1>)
	39: Ret
}

public from_keys_values<Ty0: copy, Ty1>(Arg0: vector<Ty0>, Arg1: vector<Ty1>): VecMap<Ty0, Ty1> {
L2:	loc0: VecMap<Ty0, Ty1>
B0:
	0: ImmBorrowLoc[0](Arg0: vector<Ty0>)
	1: VecLen(22)
	2: ImmBorrowLoc[1](Arg1: vector<Ty1>)
	3: VecLen(23)
	4: Eq
	5: BrFalse(7)
B1:
	6: Branch(9)
B2:
	7: LdConst[5](u64: 5)
	8: Abort
B3:
	9: MutBorrowLoc[0](Arg0: vector<Ty0>)
	10: Call vector::reverse<Ty0>(&mut vector<Ty0>)
	11: MutBorrowLoc[1](Arg1: vector<Ty1>)
	12: Call vector::reverse<Ty1>(&mut vector<Ty1>)
	13: Call empty<Ty0, Ty1>(): VecMap<Ty0, Ty1>
	14: StLoc[2](loc0: VecMap<Ty0, Ty1>)
B4:
	15: ImmBorrowLoc[0](Arg0: vector<Ty0>)
	16: VecLen(22)
	17: LdU64(0)
	18: Neq
	19: BrFalse(27)
B5:
	20: MutBorrowLoc[2](loc0: VecMap<Ty0, Ty1>)
	21: MutBorrowLoc[0](Arg0: vector<Ty0>)
	22: VecPopBack(22)
	23: MutBorrowLoc[1](Arg1: vector<Ty1>)
	24: VecPopBack(23)
	25: Call insert<Ty0, Ty1>(&mut VecMap<Ty0, Ty1>, Ty0, Ty1)
	26: Branch(15)
B6:
	27: MoveLoc[0](Arg0: vector<Ty0>)
	28: VecUnpack(22, 0)
	29: MoveLoc[1](Arg1: vector<Ty1>)
	30: VecUnpack(23, 0)
	31: MoveLoc[2](loc0: VecMap<Ty0, Ty1>)
	32: Ret
}

public keys<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>): vector<Ty0> {
L1:	loc0: &Entry<Ty0, Ty1>
L2:	loc1: u64
L3:	loc2: vector<Ty0>
L4:	loc3: u64
B0:
	0: LdU64(0)
	1: StLoc[2](loc1: u64)
	2: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	3: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	4: VecLen(20)
	5: StLoc[4](loc3: u64)
	6: VecPack(22, 0)
	7: StLoc[3](loc2: vector<Ty0>)
B1:
	8: CopyLoc[2](loc1: u64)
	9: CopyLoc[4](loc3: u64)
	10: Lt
	11: BrFalse(28)
B2:
	12: Branch(13)
B3:
	13: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	14: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	15: CopyLoc[2](loc1: u64)
	16: VecImmBorrow(20)
	17: StLoc[1](loc0: &Entry<Ty0, Ty1>)
	18: MutBorrowLoc[3](loc2: vector<Ty0>)
	19: MoveLoc[1](loc0: &Entry<Ty0, Ty1>)
	20: ImmBorrowFieldGeneric[2](Entry.key: Ty0)
	21: ReadRef
	22: VecPushBack(22)
	23: MoveLoc[2](loc1: u64)
	24: LdU64(1)
	25: Add
	26: StLoc[2](loc1: u64)
	27: Branch(8)
B4:
	28: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	29: Pop
	30: MoveLoc[3](loc2: vector<Ty0>)
	31: Ret
}

public get_idx_opt<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>, Arg1: &Ty0): Option<u64> {
L2:	loc0: u64
L3:	loc1: u64
B0:
	0: LdU64(0)
	1: StLoc[2](loc0: u64)
	2: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	3: Call size<Ty0, Ty1>(&VecMap<Ty0, Ty1>): u64
	4: StLoc[3](loc1: u64)
B1:
	5: CopyLoc[2](loc0: u64)
	6: CopyLoc[3](loc1: u64)
	7: Lt
	8: BrFalse(30)
B2:
	9: Branch(10)
B3:
	10: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	11: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	12: CopyLoc[2](loc0: u64)
	13: VecImmBorrow(20)
	14: ImmBorrowFieldGeneric[2](Entry.key: Ty0)
	15: CopyLoc[1](Arg1: &Ty0)
	16: Eq
	17: BrFalse(25)
B4:
	18: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	19: Pop
	20: MoveLoc[1](Arg1: &Ty0)
	21: Pop
	22: MoveLoc[2](loc0: u64)
	23: Call option::some<u64>(u64): Option<u64>
	24: Ret
B5:
	25: MoveLoc[2](loc0: u64)
	26: LdU64(1)
	27: Add
	28: StLoc[2](loc0: u64)
	29: Branch(5)
B6:
	30: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	31: Pop
	32: MoveLoc[1](Arg1: &Ty0)
	33: Pop
	34: Call option::none<u64>(): Option<u64>
	35: Ret
}

public get_idx<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>, Arg1: &Ty0): u64 {
L2:	loc0: Option<u64>
B0:
	0: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	1: MoveLoc[1](Arg1: &Ty0)
	2: Call get_idx_opt<Ty0, Ty1>(&VecMap<Ty0, Ty1>, &Ty0): Option<u64>
	3: StLoc[2](loc0: Option<u64>)
	4: ImmBorrowLoc[2](loc0: Option<u64>)
	5: Call option::is_some<u64>(&Option<u64>): bool
	6: BrFalse(8)
B1:
	7: Branch(10)
B2:
	8: LdConst[1](u64: 1)
	9: Abort
B3:
	10: MoveLoc[2](loc0: Option<u64>)
	11: Call option::destroy_some<u64>(Option<u64>): u64
	12: Ret
}

public get_entry_by_idx<Ty0: copy, Ty1>(Arg0: &VecMap<Ty0, Ty1>, Arg1: u64): &Ty0 * &Ty1 {
L2:	loc0: &Entry<Ty0, Ty1>
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	2: Call size<Ty0, Ty1>(&VecMap<Ty0, Ty1>): u64
	3: Lt
	4: BrFalse(6)
B1:
	5: Branch(10)
B2:
	6: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	7: Pop
	8: LdConst[3](u64: 3)
	9: Abort
B3:
	10: MoveLoc[0](Arg0: &VecMap<Ty0, Ty1>)
	11: ImmBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	12: MoveLoc[1](Arg1: u64)
	13: VecImmBorrow(20)
	14: StLoc[2](loc0: &Entry<Ty0, Ty1>)
	15: CopyLoc[2](loc0: &Entry<Ty0, Ty1>)
	16: ImmBorrowFieldGeneric[2](Entry.key: Ty0)
	17: MoveLoc[2](loc0: &Entry<Ty0, Ty1>)
	18: ImmBorrowFieldGeneric[1](Entry.value: Ty1)
	19: Ret
}

public get_entry_by_idx_mut<Ty0: copy, Ty1>(Arg0: &mut VecMap<Ty0, Ty1>, Arg1: u64): &Ty0 * &mut Ty1 {
L2:	loc0: &mut Entry<Ty0, Ty1>
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	2: FreezeRef
	3: Call size<Ty0, Ty1>(&VecMap<Ty0, Ty1>): u64
	4: Lt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	8: Pop
	9: LdConst[3](u64: 3)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	12: MutBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	13: MoveLoc[1](Arg1: u64)
	14: VecMutBorrow(20)
	15: StLoc[2](loc0: &mut Entry<Ty0, Ty1>)
	16: CopyLoc[2](loc0: &mut Entry<Ty0, Ty1>)
	17: ImmBorrowFieldGeneric[2](Entry.key: Ty0)
	18: MoveLoc[2](loc0: &mut Entry<Ty0, Ty1>)
	19: MutBorrowFieldGeneric[1](Entry.value: Ty1)
	20: Ret
}

public remove_entry_by_idx<Ty0: copy, Ty1>(Arg0: &mut VecMap<Ty0, Ty1>, Arg1: u64): Ty0 * Ty1 {
B0:
	0: CopyLoc[1](Arg1: u64)
	1: CopyLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	2: FreezeRef
	3: Call size<Ty0, Ty1>(&VecMap<Ty0, Ty1>): u64
	4: Lt
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	8: Pop
	9: LdConst[3](u64: 3)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut VecMap<Ty0, Ty1>)
	12: MutBorrowFieldGeneric[0](VecMap.contents: vector<Entry<Ty0, Ty1>>)
	13: MoveLoc[1](Arg1: u64)
	14: Call vector::remove<Entry<Ty0, Ty1>>(&mut vector<Entry<Ty0, Ty1>>, u64): Entry<Ty0, Ty1>
	15: UnpackGeneric[1](Entry<Ty0, Ty1>)
	16: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
	2 => u64: 2
	3 => u64: 3
	4 => u64: 4
	5 => u64: 5
]
}

// Move bytecode v6
module 2.vec_set {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;

struct VecSet<Ty0: copy + drop> has copy, drop, store {
	contents: vector<Ty0>
}

public empty<Ty0: copy + drop>(): VecSet<Ty0> {
B0:
	0: VecPack(2, 0)
	1: PackGeneric[0](VecSet<Ty0>)
	2: Ret
}

public singleton<Ty0: copy + drop>(Arg0: Ty0): VecSet<Ty0> {
B0:
	0: MoveLoc[0](Arg0: Ty0)
	1: VecPack(2, 1)
	2: PackGeneric[0](VecSet<Ty0>)
	3: Ret
}

public insert<Ty0: copy + drop>(Arg0: &mut VecSet<Ty0>, Arg1: Ty0) {
B0:
	0: CopyLoc[0](Arg0: &mut VecSet<Ty0>)
	1: FreezeRef
	2: ImmBorrowLoc[1](Arg1: Ty0)
	3: Call contains<Ty0>(&VecSet<Ty0>, &Ty0): bool
	4: Not
	5: BrFalse(7)
B1:
	6: Branch(11)
B2:
	7: MoveLoc[0](Arg0: &mut VecSet<Ty0>)
	8: Pop
	9: LdConst[0](u64: 0)
	10: Abort
B3:
	11: MoveLoc[0](Arg0: &mut VecSet<Ty0>)
	12: MutBorrowFieldGeneric[0](VecSet.contents: vector<Ty0>)
	13: MoveLoc[1](Arg1: Ty0)
	14: VecPushBack(2)
	15: Ret
}

public remove<Ty0: copy + drop>(Arg0: &mut VecSet<Ty0>, Arg1: &Ty0) {
L2:	loc0: u64
L3:	loc1: Option<u64>
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: Option<u64>
L8:	loc6: u64
L9:	loc7: &vector<Ty0>
B0:
	0: CopyLoc[0](Arg0: &mut VecSet<Ty0>)
	1: ImmBorrowFieldGeneric[0](VecSet.contents: vector<Ty0>)
	2: StLoc[9](loc7: &vector<Ty0>)
	3: CopyLoc[9](loc7: &vector<Ty0>)
	4: VecLen(2)
	5: StLoc[2](loc0: u64)
	6: LdU64(0)
	7: StLoc[4](loc2: u64)
	8: MoveLoc[2](loc0: u64)
	9: StLoc[8](loc6: u64)
B1:
	10: CopyLoc[4](loc2: u64)
	11: CopyLoc[8](loc6: u64)
	12: Lt
	13: BrFalse(35)
B2:
	14: CopyLoc[4](loc2: u64)
	15: StLoc[5](loc3: u64)
	16: CopyLoc[9](loc7: &vector<Ty0>)
	17: CopyLoc[5](loc3: u64)
	18: VecImmBorrow(2)
	19: CopyLoc[1](Arg1: &Ty0)
	20: Eq
	21: BrFalse(30)
B3:
	22: MoveLoc[9](loc7: &vector<Ty0>)
	23: Pop
	24: MoveLoc[1](Arg1: &Ty0)
	25: Pop
	26: MoveLoc[5](loc3: u64)
	27: Call option::some<u64>(u64): Option<u64>
	28: StLoc[3](loc1: Option<u64>)
	29: Branch(41)
B4:
	30: MoveLoc[4](loc2: u64)
	31: LdU64(1)
	32: Add
	33: StLoc[4](loc2: u64)
	34: Branch(10)
B5:
	35: MoveLoc[9](loc7: &vector<Ty0>)
	36: Pop
	37: MoveLoc[1](Arg1: &Ty0)
	38: Pop
	39: Call option::none<u64>(): Option<u64>
	40: StLoc[3](loc1: Option<u64>)
B6:
	41: MoveLoc[3](loc1: Option<u64>)
	42: StLoc[7](loc5: Option<u64>)
	43: ImmBorrowLoc[7](loc5: Option<u64>)
	44: Call option::is_some<u64>(&Option<u64>): bool
	45: BrFalse(47)
B7:
	46: Branch(53)
B8:
	47: MoveLoc[0](Arg0: &mut VecSet<Ty0>)
	48: Pop
	49: MoveLoc[7](loc5: Option<u64>)
	50: Call option::destroy_none<u64>(Option<u64>)
	51: LdConst[1](u64: 1)
	52: Abort
B9:
	53: MoveLoc[7](loc5: Option<u64>)
	54: Call option::destroy_some<u64>(Option<u64>): u64
	55: StLoc[6](loc4: u64)
	56: MoveLoc[0](Arg0: &mut VecSet<Ty0>)
	57: MutBorrowFieldGeneric[0](VecSet.contents: vector<Ty0>)
	58: MoveLoc[6](loc4: u64)
	59: Call vector::remove<Ty0>(&mut vector<Ty0>, u64): Ty0
	60: Pop
	61: Ret
}

public contains<Ty0: copy + drop>(Arg0: &VecSet<Ty0>, Arg1: &Ty0): bool {
L2:	loc0: u64
L3:	loc1: bool
L4:	loc2: u64
L5:	loc3: u64
L6:	loc4: u64
L7:	loc5: &vector<Ty0>
B0:
	0: MoveLoc[0](Arg0: &VecSet<Ty0>)
	1: ImmBorrowFieldGeneric[0](VecSet.contents: vector<Ty0>)
	2: StLoc[7](loc5: &vector<Ty0>)
	3: CopyLoc[7](loc5: &vector<Ty0>)
	4: VecLen(2)
	5: StLoc[2](loc0: u64)
	6: LdU64(0)
	7: StLoc[4](loc2: u64)
	8: MoveLoc[2](loc0: u64)
	9: StLoc[6](loc4: u64)
B1:
	10: CopyLoc[4](loc2: u64)
	11: CopyLoc[6](loc4: u64)
	12: Lt
	13: BrFalse(34)
B2:
	14: CopyLoc[4](loc2: u64)
	15: StLoc[5](loc3: u64)
	16: CopyLoc[7](loc5: &vector<Ty0>)
	17: MoveLoc[5](loc3: u64)
	18: VecImmBorrow(2)
	19: CopyLoc[1](Arg1: &Ty0)
	20: Eq
	21: BrFalse(29)
B3:
	22: MoveLoc[7](loc5: &vector<Ty0>)
	23: Pop
	24: MoveLoc[1](Arg1: &Ty0)
	25: Pop
	26: LdTrue
	27: StLoc[3](loc1: bool)
	28: Branch(40)
B4:
	29: MoveLoc[4](loc2: u64)
	30: LdU64(1)
	31: Add
	32: StLoc[4](loc2: u64)
	33: Branch(10)
B5:
	34: MoveLoc[7](loc5: &vector<Ty0>)
	35: Pop
	36: MoveLoc[1](Arg1: &Ty0)
	37: Pop
	38: LdFalse
	39: StLoc[3](loc1: bool)
B6:
	40: MoveLoc[3](loc1: bool)
	41: Ret
}

public size<Ty0: copy + drop>(Arg0: &VecSet<Ty0>): u64 {
B0:
	0: MoveLoc[0](Arg0: &VecSet<Ty0>)
	1: ImmBorrowFieldGeneric[0](VecSet.contents: vector<Ty0>)
	2: VecLen(2)
	3: Ret
}

public is_empty<Ty0: copy + drop>(Arg0: &VecSet<Ty0>): bool {
B0:
	0: MoveLoc[0](Arg0: &VecSet<Ty0>)
	1: Call size<Ty0>(&VecSet<Ty0>): u64
	2: LdU64(0)
	3: Eq
	4: Ret
}

public into_keys<Ty0: copy + drop>(Arg0: VecSet<Ty0>): vector<Ty0> {
B0:
	0: MoveLoc[0](Arg0: VecSet<Ty0>)
	1: UnpackGeneric[0](VecSet<Ty0>)
	2: Ret
}

public from_keys<Ty0: copy + drop>(Arg0: vector<Ty0>): VecSet<Ty0> {
L1:	loc0: VecSet<Ty0>
B0:
	0: MutBorrowLoc[0](Arg0: vector<Ty0>)
	1: Call vector::reverse<Ty0>(&mut vector<Ty0>)
	2: Call empty<Ty0>(): VecSet<Ty0>
	3: StLoc[1](loc0: VecSet<Ty0>)
B1:
	4: ImmBorrowLoc[0](Arg0: vector<Ty0>)
	5: VecLen(2)
	6: LdU64(0)
	7: Neq
	8: BrFalse(15)
B2:
	9: Branch(10)
B3:
	10: MutBorrowLoc[1](loc0: VecSet<Ty0>)
	11: MutBorrowLoc[0](Arg0: vector<Ty0>)
	12: VecPopBack(2)
	13: Call insert<Ty0>(&mut VecSet<Ty0>, Ty0)
	14: Branch(4)
B4:
	15: MoveLoc[1](loc0: VecSet<Ty0>)
	16: Ret
}

public keys<Ty0: copy + drop>(Arg0: &VecSet<Ty0>): &vector<Ty0> {
B0:
	0: MoveLoc[0](Arg0: &VecSet<Ty0>)
	1: ImmBorrowFieldGeneric[0](VecSet.contents: vector<Ty0>)
	2: Ret
}

Constants [
	0 => u64: 0
	1 => u64: 1
]
}

// Move bytecode v6
module 2.versioned {
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;

struct Versioned has store, key {
	id: UID,
	version: u64
}

struct VersionChangeCap {
	versioned_id: ID,
	old_version: u64
}

public create<Ty0: store>(Arg0: u64, Arg1: Ty0, Arg2: &mut TxContext): Versioned {
L3:	loc0: Versioned
B0:
	0: MoveLoc[2](Arg2: &mut TxContext)
	1: Call object::new(&mut TxContext): UID
	2: CopyLoc[0](Arg0: u64)
	3: Pack[0](Versioned)
	4: StLoc[3](loc0: Versioned)
	5: MutBorrowLoc[3](loc0: Versioned)
	6: MutBorrowField[0](Versioned.id: UID)
	7: MoveLoc[0](Arg0: u64)
	8: MoveLoc[1](Arg1: Ty0)
	9: Call dynamic_field::add<u64, Ty0>(&mut UID, u64, Ty0)
	10: MoveLoc[3](loc0: Versioned)
	11: Ret
}

public version(Arg0: &Versioned): u64 {
B0:
	0: MoveLoc[0](Arg0: &Versioned)
	1: ImmBorrowField[1](Versioned.version: u64)
	2: ReadRef
	3: Ret
}

public load_value<Ty0: store>(Arg0: &Versioned): &Ty0 {
B0:
	0: CopyLoc[0](Arg0: &Versioned)
	1: ImmBorrowField[0](Versioned.id: UID)
	2: MoveLoc[0](Arg0: &Versioned)
	3: ImmBorrowField[1](Versioned.version: u64)
	4: ReadRef
	5: Call dynamic_field::borrow<u64, Ty0>(&UID, u64): &Ty0
	6: Ret
}

public load_value_mut<Ty0: store>(Arg0: &mut Versioned): &mut Ty0 {
B0:
	0: CopyLoc[0](Arg0: &mut Versioned)
	1: MutBorrowField[0](Versioned.id: UID)
	2: MoveLoc[0](Arg0: &mut Versioned)
	3: ImmBorrowField[1](Versioned.version: u64)
	4: ReadRef
	5: Call dynamic_field::borrow_mut<u64, Ty0>(&mut UID, u64): &mut Ty0
	6: Ret
}

public remove_value_for_upgrade<Ty0: store>(Arg0: &mut Versioned): Ty0 * VersionChangeCap {
B0:
	0: CopyLoc[0](Arg0: &mut Versioned)
	1: MutBorrowField[0](Versioned.id: UID)
	2: CopyLoc[0](Arg0: &mut Versioned)
	3: ImmBorrowField[1](Versioned.version: u64)
	4: ReadRef
	5: Call dynamic_field::remove<u64, Ty0>(&mut UID, u64): Ty0
	6: CopyLoc[0](Arg0: &mut Versioned)
	7: FreezeRef
	8: Call object::id<Versioned>(&Versioned): ID
	9: MoveLoc[0](Arg0: &mut Versioned)
	10: ImmBorrowField[1](Versioned.version: u64)
	11: ReadRef
	12: Pack[1](VersionChangeCap)
	13: Ret
}

public upgrade<Ty0: store>(Arg0: &mut Versioned, Arg1: u64, Arg2: Ty0, Arg3: VersionChangeCap) {
L4:	loc0: u64
B0:
	0: MoveLoc[3](Arg3: VersionChangeCap)
	1: Unpack[1](VersionChangeCap)
	2: StLoc[4](loc0: u64)
	3: CopyLoc[0](Arg0: &mut Versioned)
	4: FreezeRef
	5: Call object::id<Versioned>(&Versioned): ID
	6: Eq
	7: BrFalse(9)
B1:
	8: Branch(13)
B2:
	9: MoveLoc[0](Arg0: &mut Versioned)
	10: Pop
	11: LdConst[0](u64: 0)
	12: Abort
B3:
	13: MoveLoc[4](loc0: u64)
	14: CopyLoc[1](Arg1: u64)
	15: Lt
	16: BrFalse(18)
B4:
	17: Branch(22)
B5:
	18: MoveLoc[0](Arg0: &mut Versioned)
	19: Pop
	20: LdConst[0](u64: 0)
	21: Abort
B6:
	22: CopyLoc[0](Arg0: &mut Versioned)
	23: MutBorrowField[0](Versioned.id: UID)
	24: CopyLoc[1](Arg1: u64)
	25: MoveLoc[2](Arg2: Ty0)
	26: Call dynamic_field::add<u64, Ty0>(&mut UID, u64, Ty0)
	27: MoveLoc[1](Arg1: u64)
	28: MoveLoc[0](Arg0: &mut Versioned)
	29: MutBorrowField[1](Versioned.version: u64)
	30: WriteRef
	31: Ret
}

public destroy<Ty0: store>(Arg0: Versioned): Ty0 {
L1:	loc0: UID
L2:	loc1: Ty0
L3:	loc2: u64
B0:
	0: MoveLoc[0](Arg0: Versioned)
	1: Unpack[0](Versioned)
	2: StLoc[3](loc2: u64)
	3: StLoc[1](loc0: UID)
	4: MutBorrowLoc[1](loc0: UID)
	5: MoveLoc[3](loc2: u64)
	6: Call dynamic_field::remove<u64, Ty0>(&mut UID, u64): Ty0
	7: StLoc[2](loc1: Ty0)
	8: MoveLoc[1](loc0: UID)
	9: Call object::delete(UID)
	10: MoveLoc[2](loc1: Ty0)
	11: Ret
}

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.zklogin_verified_id {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::string;

struct VerifiedID has key {
	id: UID,
	owner: address,
	key_claim_name: String,
	key_claim_value: String,
	issuer: String,
	audience: String
}

public owner(Arg0: &VerifiedID): address {
B0:
	0: MoveLoc[0](Arg0: &VerifiedID)
	1: ImmBorrowField[0](VerifiedID.owner: address)
	2: ReadRef
	3: Ret
}

public key_claim_name(Arg0: &VerifiedID): &String {
B0:
	0: MoveLoc[0](Arg0: &VerifiedID)
	1: ImmBorrowField[1](VerifiedID.key_claim_name: String)
	2: Ret
}

public key_claim_value(Arg0: &VerifiedID): &String {
B0:
	0: MoveLoc[0](Arg0: &VerifiedID)
	1: ImmBorrowField[2](VerifiedID.key_claim_value: String)
	2: Ret
}

public issuer(Arg0: &VerifiedID): &String {
B0:
	0: MoveLoc[0](Arg0: &VerifiedID)
	1: ImmBorrowField[3](VerifiedID.issuer: String)
	2: Ret
}

public audience(Arg0: &VerifiedID): &String {
B0:
	0: MoveLoc[0](Arg0: &VerifiedID)
	1: ImmBorrowField[4](VerifiedID.audience: String)
	2: Ret
}

public delete(Arg0: VerifiedID) {
B0:
	0: MoveLoc[0](Arg0: VerifiedID)
	1: Unpack[0](VerifiedID)
	2: Pop
	3: Pop
	4: Pop
	5: Pop
	6: Pop
	7: Call object::delete(UID)
	8: Ret
}

public verify_zklogin_id(Arg0: String, Arg1: String, Arg2: String, Arg3: String, Arg4: u256, Arg5: &mut TxContext) {
B0:
	0: LdConst[0](u64: 0)
	1: Abort
}

public check_zklogin_id(Arg0: address, Arg1: &String, Arg2: &String, Arg3: &String, Arg4: &String, Arg5: u256): bool {
B0:
	0: LdConst[0](u64: 0)
	1: Abort
}

native check_zklogin_id_internal(Arg0: address, Arg1: &vector<u8>, Arg2: &vector<u8>, Arg3: &vector<u8>, Arg4: &vector<u8>, Arg5: u256): bool;

Constants [
	0 => u64: 0
]
}

// Move bytecode v6
module 2.zklogin_verified_issuer {
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000001::string;

struct VerifiedIssuer has key {
	id: UID,
	owner: address,
	issuer: String
}

public owner(Arg0: &VerifiedIssuer): address {
B0:
	0: MoveLoc[0](Arg0: &VerifiedIssuer)
	1: ImmBorrowField[0](VerifiedIssuer.owner: address)
	2: ReadRef
	3: Ret
}

public issuer(Arg0: &VerifiedIssuer): &String {
B0:
	0: MoveLoc[0](Arg0: &VerifiedIssuer)
	1: ImmBorrowField[1](VerifiedIssuer.issuer: String)
	2: Ret
}

public delete(Arg0: VerifiedIssuer) {
B0:
	0: MoveLoc[0](Arg0: VerifiedIssuer)
	1: Unpack[0](VerifiedIssuer)
	2: Pop
	3: Pop
	4: Call object::delete(UID)
	5: Ret
}

public verify_zklogin_issuer(Arg0: u256, Arg1: String, Arg2: &mut TxContext) {
L3:	loc0: address
B0:
	0: CopyLoc[2](Arg2: &mut TxContext)
	1: FreezeRef
	2: Call tx_context::sender(&TxContext): address
	3: StLoc[3](loc0: address)
	4: CopyLoc[3](loc0: address)
	5: MoveLoc[0](Arg0: u256)
	6: ImmBorrowLoc[1](Arg1: String)
	7: Call check_zklogin_issuer(address, u256, &String): bool
	8: BrFalse(10)
B1:
	9: Branch(14)
B2:
	10: MoveLoc[2](Arg2: &mut TxContext)
	11: Pop
	12: LdConst[1](u64: 1)
	13: Abort
B3:
	14: MoveLoc[2](Arg2: &mut TxContext)
	15: Call object::new(&mut TxContext): UID
	16: CopyLoc[3](loc0: address)
	17: MoveLoc[1](Arg1: String)
	18: Pack[0](VerifiedIssuer)
	19: MoveLoc[3](loc0: address)
	20: Call transfer::transfer<VerifiedIssuer>(VerifiedIssuer, address)
	21: Ret
}

public check_zklogin_issuer(Arg0: address, Arg1: u256, Arg2: &String): bool {
B0:
	0: MoveLoc[0](Arg0: address)
	1: MoveLoc[1](Arg1: u256)
	2: MoveLoc[2](Arg2: &String)
	3: Call string::as_bytes(&String): &vector<u8>
	4: Call check_zklogin_issuer_internal(address, u256, &vector<u8>): bool
	5: Ret
}

native check_zklogin_issuer_internal(Arg0: address, Arg1: u256, Arg2: &vector<u8>): bool;

Constants [
	0 => u64: 0
	1 => u64: 1
]
}